diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,14 +1,13 @@
-# mxnet-hs
+# fei-base
 ## build
-+ LD_LIBRARY_PATH=<path-to-incubator-mxnet-lib> stack build fei-base
-
-## generate MXNet operators
-+ the repository ships pre-generated operators for various version MXNet.
-+ You can generate your own with the utility `mxnet-op-gen`: 
-  + `LD_LIBRARY_PATH=<path-to-incubator-mxnet-lib> mxnet-op-gen -o <directory-for-ops-code>`
++ Update stack.yml, pointing to the actuall MXNet dynamic library folder and include folder.
++ Build utility **mxnet-op-gen**: `stack build fei-base:mxnet-op-gen`
++ Generate tensor operations: `LD_LIBRARY_PATH=<path-to-mxnet-lib> stack exec mxnet-op-gen -- -o ops/1.6`
++ Rebuild library with tensor operations: `stack build --flag fei-base:-mxnet_geq_10600`
 
 ## see also
 + https://github.com/pierric/fei-nn
-+ https://github.com/pierric/fei-dataiter
 + https://github.com/pierric/fei-cocoapi
++ https://github.com/pierric/fei-datasets
++ https://github.com/pierric/fei-modelzoo
 + https://github.com/pierric/fei-examples
diff --git a/c-apis/MXNet/Base.hs b/c-apis/MXNet/Base.hs
--- a/c-apis/MXNet/Base.hs
+++ b/c-apis/MXNet/Base.hs
@@ -3,15 +3,17 @@
     module MXNet.Base.Raw,
     module MXNet.Base.Symbol,
     module MXNet.Base.NDArray,
+    module MXNet.Base.Tensor,
     module MXNet.Base.Executor,
     module MXNet.Base.Spec.HMap,
-    module MXNet.Base.Spec.Operator ,
+    module MXNet.Base.Spec.Operator,
 ) where
 
-import MXNet.Base.Types
-import MXNet.Base.Raw
-import MXNet.Base.Symbol
-import MXNet.Base.NDArray
-import MXNet.Base.Executor
-import MXNet.Base.Spec.HMap
-import MXNet.Base.Spec.Operator
+import           MXNet.Base.Executor
+import           MXNet.Base.NDArray
+import           MXNet.Base.Raw
+import           MXNet.Base.Spec.HMap     (HMap (..), (.&))
+import           MXNet.Base.Spec.Operator
+import           MXNet.Base.Symbol
+import           MXNet.Base.Tensor
+import           MXNet.Base.Types
diff --git a/c-apis/MXNet/Base/Executor.hs b/c-apis/MXNet/Base/Executor.hs
--- a/c-apis/MXNet/Base/Executor.hs
+++ b/c-apis/MXNet/Base/Executor.hs
@@ -1,10 +1,64 @@
+{-# LANGUAGE LambdaCase      #-}
+{-# LANGUAGE RecordWildCards #-}
 module MXNet.Base.Executor where
 
-import qualified MXNet.Base.Raw as I
-import MXNet.Base.Types (ForeignData(..))
+import           GHC.Generics       (Generic, Generic1)
+import           RIO
+import           RIO.List           (scanl, unzip)
+import qualified RIO.NonEmpty       as RNE
 
+import           MXNet.Base.NDArray (NDArray (..))
+import qualified MXNet.Base.Raw     as I
+import           MXNet.Base.Types   (Context (..), ForeignData (..))
 
 newtype Executor a = Executor { unExecutor :: I.ExecutorHandle }
+    deriving (Generic, Generic1, Show)
 
 instance ForeignData (Executor a) where
     touch = I.touchExecutorHandle . unExecutor
+
+instance NFData (Executor a)
+
+execGetOutputs :: Executor a -> IO [NDArray a]
+execGetOutputs (Executor hdl) = do
+    arrhdls <- I.mxExecutorOutputs hdl
+    return $!! map NDArray arrhdls
+
+execForward :: Executor a -> Bool -> IO ()
+execForward (Executor hdl) = I.mxExecutorForward hdl
+
+execBackward :: Executor a -> [NDArray a] -> IO ()
+execBackward (Executor hdl) arrs = I.mxExecutorBackward hdl (map unNDArray arrs)
+
+execReshapeEx :: Executor a -> Bool -> Bool -> Context -> [(Text, NonEmpty Int)] -> IO ([NDArray a], [Maybe (NDArray a)], [NDArray a], Executor a)
+execReshapeEx (Executor hdl) partial_shaping allow_up_sizing Context{..} input_shapes = do
+    let (names, shapes) = unzip input_shapes
+        arg_ind = scanl (+) 0 $ map length shapes
+        arg_shp = concatMap RNE.toList shapes
+    (new_arg_in, new_arg_grad, new_arg_aux, new_hdl) <- I.mxExecutorReshapeEx
+        partial_shaping allow_up_sizing
+        _device_type _device_id
+        [] [] []
+        names arg_shp arg_ind
+        hdl
+    let new_arg_in'   = map NDArray new_arg_in
+        new_arg_grad' = map (NDArray <$>) new_arg_grad
+        new_arg_aux'  = map NDArray new_arg_aux
+        new_exec      = Executor new_hdl
+    return $!! (new_arg_in', new_arg_grad', new_arg_aux', new_exec)
+
+execBind :: I.SymbolHandle -> Context -> [NDArray a] -> [Maybe (NDArray a, Int)] -> [NDArray a] ->  IO (Executor a)
+execBind symbol Context{..} arg_in arg_gr_with_req arg_aux = do
+    let (arg_gr, arg_gr_req) = unzip $ flip map arg_gr_with_req $ \case
+                                 Nothing -> (Nothing, 0)
+                                 Just (arr, req) -> (Just $ unNDArray arr, req)
+    hdl <- I.mxExecutorBind symbol
+                            _device_type _device_id
+                            (map unNDArray arg_in)
+                            arg_gr
+                            arg_gr_req
+                            (map unNDArray arg_aux)
+    return $ Executor hdl
+
+execFree :: Executor a -> IO ()
+execFree (Executor hdl) = I.withExecutorHandle hdl I.mxExecutorFree
diff --git a/c-apis/MXNet/Base/NDArray.hs b/c-apis/MXNet/Base/NDArray.hs
--- a/c-apis/MXNet/Base/NDArray.hs
+++ b/c-apis/MXNet/Base/NDArray.hs
@@ -1,70 +1,117 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 module MXNet.Base.NDArray where
 
-import Foreign.Ptr (castPtr)
-import Foreign.Storable (Storable(..))
-import Data.Vector.Storable (Vector)
-import qualified Data.Vector.Storable as V
+import qualified Data.Array.Repa              as Repa
+import qualified Data.Store                   as S
 import qualified Data.Vector.Storable.Mutable as VMut
-import qualified Data.Vector.Unboxed as UV
-import qualified Data.Array.Repa as Repa
-import qualified Data.Array.Repa.Eval as Repa
+import           Foreign.Ptr                  (castPtr)
+import           GHC.Generics                 (Generic, Generic1)
+import           RIO                          hiding (Vector)
+import qualified RIO.NonEmpty                 as RNE
+import qualified RIO.NonEmpty.Partial         as RNE
+import           RIO.Vector.Storable          (Vector)
+import qualified RIO.Vector.Storable          as SV
+import qualified RIO.Vector.Storable.Unsafe   as SV
+import qualified RIO.Vector.Unboxed           as UV
+import           System.IO.Unsafe
+import           Text.Printf
 
-import qualified MXNet.Base.Raw as I
-import MXNet.Base.Types (Context(..), contextCPU, DType(..), ForeignData(..))
+import           MXNet.Base.Operators.Tensor  (__copyto)
+import qualified MXNet.Base.Raw               as I
+import           MXNet.Base.Spec.HMap         (HMap (..), (.&))
+import           MXNet.Base.Spec.Operator     (ArgOf (..))
+import           MXNet.Base.Types             (Context (..), DType (..),
+                                               ForeignData (..), contextCPU)
 
 newtype NDArray a = NDArray { unNDArray :: I.NDArrayHandle}
-
+    deriving (Generic, Generic1, Show)
 instance ForeignData (NDArray a) where
     touch = I.touchNDArrayHandle . unNDArray
 
-makeEmptyNDArray :: forall a. DType a => [Int] -> Context -> IO (NDArray a)
+instance NFData (NDArray a)
+
+instance (DType a, S.Store a) => S.Store (NDArray a) where
+    size = S.VarSize $ \a ->
+                -- not ideal, I should avoid call toVector
+                let b = unsafePerformIO $ do
+                            shape <- ndshape a
+                            vec <- toVector a
+                            return (RNE.toList shape, vec)
+                    S.VarSize sz = S.size :: S.Size ([Int], SV.Vector a)
+                in sz b
+    peek = do
+        (shape, vec) <- S.peek
+        liftIO $ fromVector shape vec
+    poke a = do
+        shape <- liftIO $ ndshape a
+        vec <- liftIO $ toVector a
+        S.poke (shape, vec)
+
+makeEmptyNDArray :: forall a. DType a => NonEmpty Int -> Context -> IO (NDArray a)
 makeEmptyNDArray shape ctx = do
-    array <- I.mxNDArrayCreateEx shape (_device_type ctx) (_device_id ctx) False (flag (undefined :: a))
+    array <- I.mxNDArrayCreateEx (RNE.toList shape)
+                                 (_device_type ctx)
+                                 (_device_id ctx)
+                                 False
+                                 (flag (undefined :: a))
     return $ NDArray array
 
-makeNDArray :: forall a. DType a => [Int] -> Context -> Vector a -> IO (NDArray a)
+makeNDArray :: forall a. DType a => NonEmpty Int -> Context -> Vector a -> IO (NDArray a)
 makeNDArray shape ctx vec = do
-    array <- I.mxNDArrayCreateEx shape (_device_type ctx) (_device_id ctx) False (flag (undefined :: a))
-    V.unsafeWith vec $ \p -> do
-        I.mxNDArraySyncCopyFromCPU array (castPtr p) (V.length vec)
+    array <- I.mxNDArrayCreateEx (RNE.toList shape)
+                                 (_device_type ctx)
+                                 (_device_id ctx)
+                                 False
+                                 (flag (undefined :: a))
+    SV.unsafeWith vec $ \p -> do
+        I.mxNDArraySyncCopyFromCPU array (castPtr p) (SV.length vec)
         return $ NDArray array
 
 makeNDArrayLike :: DType a => NDArray a -> Context -> IO (NDArray a)
 makeNDArrayLike src cxt = do
     shape <- ndshape src
     makeEmptyNDArray shape cxt
-        
-ndshape :: DType a => NDArray a -> IO [Int]
-ndshape = I.mxNDArrayGetShape . unNDArray
 
+ndshape :: DType a => NDArray a -> IO (NonEmpty Int)
+ndshape arr = do
+    shape <- I.mxNDArrayGetShape $ unNDArray arr
+    case RNE.nonEmpty shape of
+        Just s  -> return s
+        Nothing -> error "impossible shape"
+
 ndsize :: DType a => NDArray a -> IO Int
 ndsize arr = product <$> ndshape arr
 
-full :: DType a => a -> [Int] -> IO (NDArray a)
-full value shape = makeNDArray shape contextCPU $ V.replicate (product shape) value
+full :: DType a => a -> NonEmpty Int -> IO (NDArray a)
+full value shape = makeNDArray shape contextCPU $ SV.replicate (product shape) value
 
-ones :: DType a => [Int] -> IO (NDArray a)
+ones :: DType a => NonEmpty Int -> IO (NDArray a)
 ones = full 1
 
-zeros :: DType a => [Int] -> IO (NDArray a)
+zeros :: DType a => NonEmpty Int -> IO (NDArray a)
 zeros = full 1
 
-fromVector :: DType a => [Int] -> Vector a -> IO (NDArray a)
+fromVector :: DType a => NonEmpty Int -> Vector a -> IO (NDArray a)
 fromVector shape = makeNDArray shape contextCPU
 
-copyFromVector :: DType a => NDArray a -> Vector a -> IO ()
+fromRepa :: (HasCallStack, Repa.Shape sh, DType a, UV.Unbox a) => Repa.Array Repa.U sh a -> IO (NDArray a)
+fromRepa arr = do
+    let shp = RNE.fromList $ reverse $ Repa.listOfShape $ Repa.extent arr
+        vec = UV.convert $ Repa.toUnboxed arr
+    makeNDArray shp contextCPU vec
+
+copyFromVector :: (HasCallStack, DType a) => NDArray a -> Vector a -> IO ()
 copyFromVector arr vec = do
     sz <- ndsize arr
-    if (sz /= V.length vec) 
-      then error ""
+    if (sz /= SV.length vec)
+      then error $ printf "cannot copy from Vector: size mismatch (%d vs. %d)" sz (SV.length vec)
       else do
-        V.unsafeWith vec $ \p -> do
+        SV.unsafeWith vec $ \p -> do
             I.mxNDArraySyncCopyFromCPU (unNDArray arr) (castPtr p) sz
 
-copyFromRepa :: (Repa.Shape sh, DType a, UV.Unbox a, Repa.Load r sh a) => NDArray a -> Repa.Array r sh a -> IO ()
+copyFromRepa :: (HasCallStack, Repa.Shape sh, DType a, UV.Unbox a) => NDArray a -> Repa.Array Repa.U sh a -> IO ()
 copyFromRepa arr repa = do
-    let vec = UV.convert $ Repa.toUnboxed $ Repa.computeS repa
+    let vec = UV.convert $ Repa.toUnboxed repa
     copyFromVector arr vec
 
 toVector :: DType a => NDArray a -> IO (Vector a)
@@ -72,11 +119,11 @@
     nlen <- ndsize arr
     mvec <- VMut.new nlen
     VMut.unsafeWith mvec $ \p -> I.mxNDArraySyncCopyToCPU (unNDArray arr) (castPtr p) nlen
-    V.unsafeFreeze mvec
+    SV.unsafeFreeze mvec
 
 toRepa :: (Repa.Shape sh, DType a, UV.Unbox a) => NDArray a -> IO (Repa.Array Repa.U sh a)
 toRepa arr = do
-    shp <- ndshape arr
+    shp <- RNE.toList <$> ndshape arr
     vec <- toVector arr
     return $ Repa.fromUnboxed (Repa.shapeOfList (reverse shp)) (UV.convert vec)
 
@@ -85,10 +132,36 @@
     cxt <- I.mxNDArrayGetContext handle
     return $ uncurry Context cxt
 
+toContext :: forall a. DType a => NDArray a -> Context -> IO (NDArray a)
+toContext arr cxt = do
+    ncxt <- context arr
+    if cxt == ncxt
+    then return arr
+    else do
+        narr <- makeNDArrayLike arr cxt
+        void $ (__copyto (#data :≅ arr .& Nil) (Just [narr]) :: IO [NDArray a])
+        return narr
+
+toCPU :: DType a => NDArray a -> IO (NDArray a)
+toCPU = flip toContext contextCPU
+
 waitToRead :: DType a => NDArray a -> IO ()
 waitToRead (NDArray hdl) = I.mxNDArrayWaitToRead hdl
 
 waitToWrite :: DType a => NDArray a -> IO ()
 waitToWrite (NDArray hdl) = I.mxNDArrayWaitToWrite hdl
 
+waitAll :: IO ()
 waitAll = I.mxNDArrayWaitAll
+
+-- All non-update OP return a list of NDArray, but usually
+-- it is a single element list. `sing` check and return
+-- the first NDArray
+sing :: (args -> IO [I.NDArrayHandle]) -> args -> IO I.NDArrayHandle
+sing op args = do
+    res <- op args
+    case res of
+      [x] -> return x
+      _   -> error "OP result is not a single NDArray."
+
+emptyCache context = I.mxStorageEmptyCache (_device_type context) (_device_id context)
diff --git a/c-apis/MXNet/Base/NDArray.hs-boot b/c-apis/MXNet/Base/NDArray.hs-boot
new file mode 100644
--- /dev/null
+++ b/c-apis/MXNet/Base/NDArray.hs-boot
@@ -0,0 +1,6 @@
+module MXNet.Base.NDArray where
+
+import qualified MXNet.Base.Raw               as I
+
+newtype NDArray a = NDArray { unNDArray :: I.NDArrayHandle}
+
diff --git a/c-apis/MXNet/Base/ParserUtils.hs b/c-apis/MXNet/Base/ParserUtils.hs
new file mode 100644
--- /dev/null
+++ b/c-apis/MXNet/Base/ParserUtils.hs
@@ -0,0 +1,22 @@
+module MXNet.Base.ParserUtils (
+    parseR,
+    list,
+    tuple,
+    module Data.Attoparsec.Text
+) where
+
+import           Control.Lens         (ix, (^?!), _Right)
+import           Data.Attoparsec.Text
+import qualified Data.Attoparsec.Text as P
+import           RIO
+
+parseR :: HasCallStack => P.Parser a -> Text -> a
+parseR c t = (parseOnly (c <* endOfInput) t) ^?! _Right
+
+list  f = char '[' *> commaSep f <* char ']'
+tuple f = char '(' *> liftA2 (,) f (char ',' *> f) <* char ')'
+
+-- TODO give type level int, build a tuple of that size
+many f = char '(' *> commaSep f <* char ')'
+
+commaSep p  = p `sepBy` (char ',')
diff --git a/c-apis/MXNet/Base/Raw/Common.chs b/c-apis/MXNet/Base/Raw/Common.chs
--- a/c-apis/MXNet/Base/Raw/Common.chs
+++ b/c-apis/MXNet/Base/Raw/Common.chs
@@ -1,43 +1,71 @@
 module MXNet.Base.Raw.Common where
 
-import Control.Exception.Base (Exception, throwIO)
-import Data.Typeable (Typeable)
+import RIO
+import qualified RIO.Text as T
 import Data.Tuple.Ops (Unconsable, uncons)
 import Foreign.Marshal (alloca, peekArray, withArray)
 import Foreign.Storable (Storable(..))
-import Foreign.C (withCString)
 import Foreign.C.Types
+import Foreign.C.String (CString, peekCString, withCString)
 import Foreign.Ptr
-import C2HS.C.Extra.Marshal (peekString, peekStringArray)
 import GHC.Generics (Generic)
-import Data.Word (Word64)
+import GHC.Stack
 
 type MX_UINT  = C2HSImp.CUInt
 type MX_CCHAR = C2HSImp.CChar
 
-data MXNetError = MXNetError String
+{# typedef char CChar #}
+{# default in  `Text' [char *] withCStringT* #}
+{# default out `Text' [char *] peekCStringT* #}
+
+data MXNetError = MXNetError String Text
     deriving Typeable
 instance Exception MXNetError
 
 instance Show MXNetError where
-    show (MXNetError msg) = "an error occurred in MXNet.\n" ++ msg
+    show (MXNetError tb msg) = tb ++ "\n\nAn error occurred in MXNet.\n" ++ T.unpack msg
 
+newtype WrapText = WrapText {unWrapText :: Text}
+deriving instance Generic WrapText
 deriving instance Generic C2HSImp.CInt
 deriving instance Generic C2HSImp.CUInt
 
-checked :: Unconsable t CInt r => IO t -> IO r
+checked :: (HasCallStack, Unconsable t CInt r) => IO t -> IO r
 checked call = do
     (res, ret) <- uncons <$> call
     if res < 0
       then do err <- mxGetLastError
-              throwIO $ MXNetError err
+              let tb = prettyCallStack callStack
+              throwIO $ MXNetError tb err
       else return ret
 
-withStringArray :: [String] -> (Ptr (Ptr CChar) -> IO a) -> IO a
-withStringArray strs act = go strs []
+peekCStringT :: CString -> IO Text
+peekCStringT = fmap T.pack . peekCString
+
+peekCStringPtrT :: Ptr CString -> IO Text
+peekCStringPtrT ptr = do
+    cstr <- peek ptr
+    if | cstr == nullPtr -> return ""
+       | otherwise -> peekCStringT cstr
+
+peekCStringArrayT :: Int -> Ptr CString -> IO [Text]
+peekCStringArrayT cnt ptr = peekArray cnt ptr >>= mapM peekCStringT
+
+withCStringT :: Text -> (CString -> IO a) -> IO a
+withCStringT str = withCString (T.unpack str)
+
+-- TODO: Does it worth of any opt for the withCStringArrayT?
+-- withCStringArrayT :: [Text] -> (Ptr CString -> IO a) -> IO a
+-- withCStringArrayT arr act = do
+--     let nul = T.singleton '\NUL'
+--         whole = T.concat $ map (`T.append` nul) arr
+--     T.encodeUtf8 whole
+
+withCStringArrayT :: [Text] -> (Ptr CString -> IO a) -> IO a
+withCStringArrayT strs act = go strs []
   where
     go [] all = withArray (reverse all) act
-    go (s:ss) all = withCString s (go ss . (:all))
+    go (s:ss) all = withCStringT s (go ss . (:all))
 
 #include <mxnet/c_api.h>
 #include <nnvm/c_api.h>
@@ -60,15 +88,15 @@
     } -> `CInt'
 #}
 
-mxListAllOpNames :: IO [String]
+mxListAllOpNames :: IO [Text]
 mxListAllOpNames = do
     (cnt, ptr) <- checked mxListAllOpNames_
-    peekStringArray (fromIntegral cnt :: Int) ptr
+    peekCStringArrayT (fromIntegral cnt :: Int) ptr
 
 {#
 fun MXGetLastError as mxGetLastError
     {
-    } -> `String'
+    } -> `Text' peekCStringT*
 #}
 
 {#
@@ -102,42 +130,42 @@
 fun MXSymbolGetAtomicSymbolName as mxSymbolGetAtomicSymbolName_
     {
         `AtomicSymbolCreator',
-        alloca- `String' peekString*
+        alloca- `Text' peekCStringPtrT*
     } -> `CInt'
 #}
 
-mxSymbolGetAtomicSymbolName :: AtomicSymbolCreator -> IO String
-mxSymbolGetAtomicSymbolName = checked . mxSymbolGetAtomicSymbolName_
+mxSymbolGetAtomicSymbolName :: AtomicSymbolCreator -> IO Text
+mxSymbolGetAtomicSymbolName = fmap unWrapText . checked . fmap (second WrapText) . mxSymbolGetAtomicSymbolName_
 
 {#
 fun MXSymbolGetAtomicSymbolInfo as mxSymbolGetAtomicSymbolInfo_
     {
         `AtomicSymbolCreator',
-        alloca- `String' peekString*,
-        alloca- `String' peekString*,
+        alloca- `Text' peekCStringPtrT*,
+        alloca- `Text' peekCStringPtrT*,
         alloca- `MX_UINT' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*,
-        alloca- `String' peekString*,
-        alloca- `String' peekString*
+        alloca- `Ptr CString' peek*,
+        alloca- `Ptr CString' peek*,
+        alloca- `Ptr CString' peek*,
+        alloca- `Text' peekCStringPtrT*,
+        alloca- `Text' peekCStringPtrT*
     } -> `CInt'
 #}
 
 mxSymbolGetAtomicSymbolInfo :: AtomicSymbolCreator
-                            -> IO (String,
-                                   String,
-                                   [String],
-                                   [String],
-                                   [String],
-                                   String,
-                                   String)
+                            -> IO (Text,
+                                   Text,
+                                   [Text],
+                                   [Text],
+                                   [Text],
+                                   Text,
+                                   Text)
 mxSymbolGetAtomicSymbolInfo creator = do
     (name, desc, argcnt, argname, argtype, argdesc, key_var_num_args, rettyp) <- checked $ mxSymbolGetAtomicSymbolInfo_ creator
     let n = fromIntegral argcnt
-    argname <- peekStringArray n argname
-    argtype <- peekStringArray n argtype
-    argdesc <- peekStringArray n argdesc
+    argname <- peekCStringArrayT n argname
+    argtype <- peekCStringArrayT n argtype
+    argdesc <- peekCStringArrayT n argdesc
     return (name, desc, argname, argtype, argdesc, key_var_num_args, rettyp)
 
 {#
@@ -149,6 +177,17 @@
 mxNotifyShutdown :: IO ()
 mxNotifyShutdown = checked mxNotifyShutdown_
 
+
+{#
+fun MXRandomSeed as mxRandomSeed_
+    {
+        `CInt'
+    } -> `CInt'
+#}
+
+mxRandomSeed :: Int -> IO ()
+mxRandomSeed seed = checked $ mxRandomSeed_ (fromIntegral seed)
+
 ---------------------------------------------------
 type NN_UINT  = C2HSImp.CUInt
 
@@ -168,10 +207,10 @@
     } -> `CInt'
 #}
 
-nnListAllOpNames :: IO [String]
+nnListAllOpNames :: IO [Text]
 nnListAllOpNames = do
     (cnt, ptr) <- checked nnListAllOpNames_
-    peekStringArray (fromIntegral cnt :: Int) ptr
+    peekCStringArrayT (fromIntegral cnt) ptr
 
 {#
 fun NNListUniqueOps as nnListUniqueOps_
@@ -189,39 +228,50 @@
 {#
 fun NNGetOpHandle as nnGetOpHandle_
     {
-        `String',
+        withCStringT* `Text',
         alloca- `OpHandle' peek*
     } -> `CInt'
 #}
 
-nnGetOpHandle :: String -> IO OpHandle
+nnGetOpHandle :: Text -> IO OpHandle
 nnGetOpHandle = checked . nnGetOpHandle_
 
 {#
 fun NNGetOpInfo as nnGetOpInfo_
     {
         `OpHandle',
-        alloca- `String' peekString*,
-        alloca- `String' peekString*,
+        alloca- `Text' peekCStringPtrT*,
+        alloca- `Text' peekCStringPtrT*,
         alloca- `NN_UINT' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*,
-        alloca- `String' peekString*
+        alloca- `Ptr CString' peek*,
+        alloca- `Ptr CString' peek*,
+        alloca- `Ptr CString' peek*,
+        alloca- `Text' peekCStringPtrT*
     } -> `CInt'
 #}
 
-nnGetOpInfo :: OpHandle -> IO (String, String, [String], [String], [String], String)
+nnGetOpInfo :: OpHandle -> IO (Text, Text, [Text], [Text], [Text], Text)
 nnGetOpInfo op = do
     (name, desc, num_args, ptr_arg_names, ptr_arg_types, ptr_arg_descs, ret_type) <- checked $ nnGetOpInfo_ op
     let num_args_ = fromIntegral num_args
-    arg_names <- peekStringArray num_args_ ptr_arg_names
-    arg_types <- peekStringArray num_args_ ptr_arg_types
-    arg_descs <- peekStringArray num_args_ ptr_arg_descs
+    arg_names <- peekCStringArrayT num_args_ ptr_arg_names
+    arg_types <- peekCStringArrayT num_args_ ptr_arg_types
+    arg_descs <- peekCStringArrayT num_args_ ptr_arg_descs
     return (name, desc, arg_names, arg_types, arg_descs, ret_type)
 
 {#
 fun NNGetLastError as nnGetLastError
     {
-    } -> `String'
+    } -> `Text' peekCStringT*
 #}
+
+{#
+fun MXStorageEmptyCache as mxStorageEmptyCache_
+    {
+        `CInt',
+        `CInt'
+    } -> `CInt'
+#}
+
+mxStorageEmptyCache :: Int -> Int -> IO ()
+mxStorageEmptyCache devtype devid = checked $ mxStorageEmptyCache_ (fromIntegral devtype) (fromIntegral devid)
diff --git a/c-apis/MXNet/Base/Raw/DataIter.chs b/c-apis/MXNet/Base/Raw/DataIter.chs
--- a/c-apis/MXNet/Base/Raw/DataIter.chs
+++ b/c-apis/MXNet/Base/Raw/DataIter.chs
@@ -1,16 +1,14 @@
 module MXNet.Base.Raw.DataIter where
 
+import RIO
 import Data.Typeable (Typeable)
 import Foreign.Marshal (alloca, peekArray)
 import Foreign.Storable (Storable(..))
 import Foreign.Concurrent (newForeignPtr)
 import Foreign.ForeignPtr (finalizeForeignPtr)
 import Foreign.C.Types
+import Foreign.C.String (CString)
 import Foreign.Ptr
-import Data.Word (Word64)
-import C2HS.C.Extra.Marshal (peekString, peekStringArray, peekIntegralArray)
-import GHC.Generics (Generic)
-import Control.Monad ((>=>))
 
 {# import MXNet.Base.Raw.Common #}
 {# import MXNet.Base.Raw.NDArray #}
@@ -30,7 +28,7 @@
 deriving instance Storable DataIterCreator
 
 {#
-pointer DataIterHandle foreign newtype 
+pointer DataIterHandle foreign newtype
 #}
 
 deriving instance Generic DataIterHandle
@@ -59,10 +57,10 @@
 
 {#
 fun MXListDataIters as mxListDataIters_
-    { 
-        alloca- `MX_UINT' peek*, 
+    {
+        alloca- `MX_UINT' peek*,
         alloca- `Ptr DataIterCreator' peek*
-    } -> `CInt' 
+    } -> `CInt'
 #}
 
 mxListDataIters :: IO [DataIterCreator]
@@ -72,46 +70,59 @@
 
 {#
 fun MXDataIterGetIterInfo as mxDataIterGetIterInfo_
-    { 
-        `DataIterCreator', 
-        alloca- `String' peekString*,
-        alloca- `String' peekString*,
+    {
+        `DataIterCreator',
+        alloca- `Text' peekCStringPtrT*,
+        alloca- `Text' peekCStringPtrT*,
         alloca- `MX_UINT' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*
+        alloca- `Ptr CString' peek*,
+        alloca- `Ptr CString' peek*,
+        alloca- `Ptr CString' peek*
     } -> `CInt'
 #}
 
-mxDataIterGetIterInfo :: DataIterCreator -> IO (String, String, [String], [String], [String])
+mxDataIterGetIterInfo :: DataIterCreator -> IO (Text, Text, [Text], [Text], [Text])
 mxDataIterGetIterInfo dataitercreator = do
     (name, descr, num_args, arg_names, arg_type_infos, arg_descs) <- checked $ mxDataIterGetIterInfo_ dataitercreator
     let num_args_ = fromIntegral num_args
-    arg_names_ <- peekStringArray num_args_ arg_names
-    arg_type_infos_ <- peekStringArray num_args_ arg_type_infos
-    arg_descs_ <- peekStringArray num_args_ arg_descs
+    arg_names_ <- peekCStringArrayT num_args_ arg_names
+    arg_type_infos_ <- peekCStringArrayT num_args_ arg_type_infos
+    arg_descs_ <- peekCStringArrayT num_args_ arg_descs
     return (name, descr, arg_names_, arg_type_infos_, arg_descs_)
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXDataIterCreateIter as mxDataIterCreateIter_
-    { 
-        `DataIterCreator', 
+    {
+        `DataIterCreator',
         `MX_UINT',
-        withStringArray* `[String]',
-        withStringArray* `[String]',
+        withCStringArrayT* `[Text]',
+        withCStringArrayT* `[Text]',
         alloca- `DataIterHandle' peekDataIterHandle*
     } -> `CInt'
 #}
+#else
+{#
+fun MXDataIterCreateIter as mxDataIterCreateIter_
+    {
+        `DataIterCreator',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        withCStringArrayT* `[Text]',
+        alloca- `DataIterHandle' peekDataIterHandle*
+    } -> `CInt'
+#}
+#endif
 
-mxDataIterCreateIter :: DataIterCreator -> [String] -> [String] -> IO DataIterHandle
+mxDataIterCreateIter :: DataIterCreator -> [Text] -> [Text] -> IO DataIterHandle
 mxDataIterCreateIter dataitercreator keys vals = do
     let num_args = fromIntegral (length keys)
     checked $ mxDataIterCreateIter_ dataitercreator num_args keys vals
 
 {#
 fun MXDataIterNext as mxDataIterNext_
-    { 
-        `DataIterHandle', 
+    {
+        `DataIterHandle',
         alloca- `CInt' peek*
     } -> `CInt'
 #}
@@ -123,7 +134,7 @@
 
 {#
 fun MXDataIterBeforeFirst as mxDataIterBeforeFirst_
-    { 
+    {
         `DataIterHandle'
     } -> `CInt'
 #}
@@ -133,7 +144,7 @@
 
 {#
 fun MXDataIterGetData as mxDataIterGetData_
-    { 
+    {
         `DataIterHandle',
         alloca- `NDArrayHandle' peekNDArrayHandle*
     } -> `CInt'
@@ -144,7 +155,7 @@
 
 {#
 fun MXDataIterGetIndex as mxDataIterGetIndex_
-    { 
+    {
         `DataIterHandle',
         alloca- `Ptr Word64' peek*,
         alloca- `Word64' peek*
@@ -154,11 +165,11 @@
 mxDataIterGetIndex :: DataIterHandle -> IO [Integer]
 mxDataIterGetIndex dataiter = do
     (ptr, cnt) <- checked $ mxDataIterGetIndex_ dataiter
-    peekIntegralArray (fromIntegral cnt) ptr
+    map fromIntegral <$> peekArray (fromIntegral cnt) ptr
 
 {#
 fun MXDataIterGetPadNum as mxDataIterGetPadNum_
-    { 
+    {
         `DataIterHandle',
         alloca- `CInt' peek*
     } -> `CInt'
@@ -171,7 +182,7 @@
 
 {#
 fun MXDataIterGetLabel as mxDataIterGetLabel_
-    { 
+    {
         `DataIterHandle',
         alloca- `NDArrayHandle' peekNDArrayHandle*
     } -> `CInt'
diff --git a/c-apis/MXNet/Base/Raw/Executor.chs b/c-apis/MXNet/Base/Raw/Executor.chs
--- a/c-apis/MXNet/Base/Raw/Executor.chs
+++ b/c-apis/MXNet/Base/Raw/Executor.chs
@@ -1,6 +1,7 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 module MXNet.Base.Raw.Executor where
 
+import RIO
 import Foreign.Marshal (alloca, withArray, peekArray)
 import Foreign.Storable (Storable(..))
 import Foreign.Concurrent (newForeignPtr)
@@ -8,10 +9,7 @@
 import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)
 import Foreign.Ptr
 import Foreign.C.Types
-import C2HS.C.Extra.Marshal (withIntegralArray, peekIntegralArray, peekString, peekStringArray)
-import GHC.Generics (Generic)
-import Control.Monad ((>=>))
-import Data.Maybe (fromMaybe)
+import Control.DeepSeq (NFData(..), rwhnf)
 
 {# import MXNet.Base.Raw.Common #}
 {# import MXNet.Base.Raw.NDArray #}
@@ -25,10 +23,13 @@
 {# default in `MX_UINT' [mx_uint] id #}
 
 {#
-pointer ExecutorHandle foreign newtype 
+pointer ExecutorHandle foreign newtype
 #}
 
 deriving instance Generic ExecutorHandle
+deriving instance Show ExecutorHandle
+instance NFData ExecutorHandle where
+    rnf = rwhnf
 
 type ExecutorHandlePtr = Ptr ExecutorHandle
 
@@ -36,7 +37,7 @@
 touchExecutorHandle (ExecutorHandle fptr) = touchForeignPtr fptr
 
 newExecutorHandle :: ExecutorHandlePtr -> IO ExecutorHandle
-newExecutorHandle ptr = newForeignPtr ptr (mxExecutorFree ptr) >>= return . ExecutorHandle
+newExecutorHandle ptr = newForeignPtr_ ptr >>= return . ExecutorHandle
 
 peekExecutorHandle :: Ptr ExecutorHandlePtr -> IO ExecutorHandle
 peekExecutorHandle = peek >=> newExecutorHandle
@@ -62,12 +63,12 @@
 fun MXExecutorPrint as mxExecutorPrint_
     {
         `ExecutorHandle',
-        alloca- `String' peekString*
+        alloca- `Text' peekCStringPtrT*
     } -> `CInt'
 #}
 
-mxExecutorPrint :: ExecutorHandle -> IO String
-mxExecutorPrint = checked . mxExecutorPrint_
+mxExecutorPrint :: ExecutorHandle -> IO Text
+mxExecutorPrint = fmap unWrapText . checked . fmap (second WrapText) . mxExecutorPrint_
 
 {#
 fun MXExecutorForward as mxExecutorForward_
@@ -82,6 +83,7 @@
   where
     is_train = if train then 1 else 0
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXExecutorBackward as mxExecutorBackward_
     {
@@ -90,12 +92,23 @@
         withNDArrayHandleArray* `[NDArrayHandle]'
     } -> `CInt'
 #}
+#else
+{#
+fun MXExecutorBackward as mxExecutorBackward_
+    {
+        `ExecutorHandle',
+        `CUInt',
+        withNDArrayHandleArray* `[NDArrayHandle]'
+    } -> `CInt'
+#}
+#endif
 
 mxExecutorBackward :: ExecutorHandle -> [NDArrayHandle] -> IO ()
 mxExecutorBackward exec head_grads = checked $ mxExecutorBackward_ exec cnt head_grads
   where
     cnt = fromIntegral $ length head_grads
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXExecutorBackwardEx as mxExecutorBackwardEx_
     {
@@ -105,6 +118,17 @@
         `CInt'
     } -> `CInt'
 #}
+#else
+{#
+fun MXExecutorBackwardEx as mxExecutorBackwardEx_
+    {
+        `ExecutorHandle',
+        `CUInt',
+        withNDArrayHandleArray* `[NDArrayHandle]',
+        `CInt'
+    } -> `CInt'
+#}
+#endif
 
 mxExecutorBackwardEx :: ExecutorHandle -> [NDArrayHandle] -> Bool -> IO ()
 mxExecutorBackwardEx exec head_grads train = checked $ mxExecutorBackwardEx_ exec cnt head_grads is_train
@@ -127,6 +151,7 @@
     handle_ptrs <- peekArray (fromIntegral cnt) ptr
     mapM newNDArrayHandle handle_ptrs
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXExecutorBind as mxExecutorBind_
     {
@@ -142,12 +167,29 @@
         alloca- `ExecutorHandle' peekExecutorHandle*
     } -> `CInt'
 #}
+#else
+{#
+fun MXExecutorBind as mxExecutorBind_
+    {
+        `SymbolHandle',
+        `CInt',
+        `CInt',
+        `CUInt',
+        withNDArrayHandleArray* `[NDArrayHandle]',
+        withNDArrayHandleArray* `[NDArrayHandle]',
+        withArray* `[CUInt]',
+        `CUInt',
+        withNDArrayHandleArray* `[NDArrayHandle]',
+        alloca- `ExecutorHandle' peekExecutorHandle*
+    } -> `CInt'
+#}
+#endif
 
 makeNullNDArrayHandle = NDArrayHandle <$> newForeignPtr_ C2HSImp.nullPtr
 
 mxExecutorBind :: SymbolHandle
-               -> Int 
                -> Int
+               -> Int
                -> [NDArrayHandle]
                -> [Maybe NDArrayHandle]
                -> [Int]
@@ -164,6 +206,7 @@
     cnt_auxs = fromIntegral $ length aux_states
     grad_req_type_ = map fromIntegral grad_req_type
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXExecutorBindX as mxExecutorBindX_
     {
@@ -171,7 +214,7 @@
         `CInt',
         `CInt',
         `MX_UINT',
-        withStringArray* `[String]',
+        withCStringArrayT* `[Text]',
         withArray* `[CInt]',
         withArray* `[CInt]',
         `MX_UINT',
@@ -183,11 +226,32 @@
         alloca- `ExecutorHandle' peekExecutorHandle*
     } -> `CInt'
 #}
+#else
+{#
+fun MXExecutorBindX as mxExecutorBindX_
+    {
+        `SymbolHandle',
+        `CInt',
+        `CInt',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        withArray* `[CInt]',
+        withArray* `[CInt]',
+        `CUInt',
+        withNDArrayHandleArray* `[NDArrayHandle]',
+        withNDArrayHandleArray* `[NDArrayHandle]',
+        withArray* `[CUInt]',
+        `CUInt',
+        withNDArrayHandleArray* `[NDArrayHandle]',
+        alloca- `ExecutorHandle' peekExecutorHandle*
+    } -> `CInt'
+#}
+#endif
 
 mxExecutorBindX :: SymbolHandle
-                -> Int 
                 -> Int
-                -> [String]
+                -> Int
+                -> [Text]
                 -> [Int]
                 -> [Int]
                 -> [NDArrayHandle]
@@ -209,6 +273,7 @@
     cnt_auxs = fromIntegral $ length aux_states
     grad_req_type_ = map fromIntegral grad_req_type
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXExecutorBindEX as mxExecutorBindEX_
     {
@@ -216,7 +281,7 @@
         `CInt',
         `CInt',
         `MX_UINT',
-        withStringArray* `[String]',
+        withCStringArrayT* `[Text]',
         withArray* `[CInt]',
         withArray* `[CInt]',
         `MX_UINT',
@@ -229,11 +294,33 @@
         alloca- `ExecutorHandle' peekExecutorHandle*
     } -> `CInt'
 #}
+#else
+{#
+fun MXExecutorBindEX as mxExecutorBindEX_
+    {
+        `SymbolHandle',
+        `CInt',
+        `CInt',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        withArray* `[CInt]',
+        withArray* `[CInt]',
+        `CUInt',
+        withNDArrayHandleArray* `[NDArrayHandle]',
+        withNDArrayHandleArray* `[NDArrayHandle]',
+        withArray* `[CUInt]',
+        `CUInt',
+        withNDArrayHandleArray* `[NDArrayHandle]',
+        `ExecutorHandle',
+        alloca- `ExecutorHandle' peekExecutorHandle*
+    } -> `CInt'
+#}
+#endif
 
 mxExecutorBindEX :: SymbolHandle
-                 -> Int 
                  -> Int
-                 -> [String]
+                 -> Int
+                 -> [Text]
                  -> [Int]
                  -> [Int]
                  -> [NDArrayHandle]
@@ -256,6 +343,7 @@
     cnt_auxs = fromIntegral $ length aux_states
     grad_req_type_ = map fromIntegral grad_req_type
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXExecutorSimpleBind as mxExecutorSimpleBind_
     {
@@ -263,24 +351,24 @@
         `CInt',
         `CInt',
         `MX_UINT',
-        withStringArray* `[String]',
+        withCStringArrayT* `[Text]',
         withArray* `[CInt]',
         withArray* `[CInt]',
         `MX_UINT',
-        withStringArray* `[String]',
-        withStringArray* `[String]',
+        withCStringArrayT* `[Text]',
+        withCStringArrayT* `[Text]',
         `MX_UINT',
-        withStringArray* `[String]',
+        withCStringArrayT* `[Text]',
         withArray* `[MX_UINT]',
         withArray* `[MX_UINT]',
         `MX_UINT',
-        withStringArray* `[String]',
+        withCStringArrayT* `[Text]',
         withArray* `[CInt]',
         `MX_UINT',
-        withStringArray* `[String]',
+        withCStringArrayT* `[Text]',
         withArray* `[CInt]',
         `MX_UINT',
-        withStringArray* `[String]',
+        withCStringArrayT* `[Text]',
         id `Ptr CInt',                          -- [in/out] shared_buffer_len
         id `Ptr (Ptr CChar)',                   -- [in, optional] shared_buffer_name_list
         id `Ptr NDArrayHandlePtr',              -- [in, optional] shared_buffer_handle_list
@@ -292,44 +380,85 @@
         alloca- `MX_UINT' peek*,
         alloca- `Ptr NDArrayHandlePtr' peek*,
         `ExecutorHandle',
-        alloca- `ExecutorHandle' peekExecutorHandle*        
+        alloca- `ExecutorHandle' peekExecutorHandle*
     } -> `CInt'
 #}
+#else
+{#
+fun MXExecutorSimpleBind as mxExecutorSimpleBind_
+    {
+        `SymbolHandle',
+        `CInt',
+        `CInt',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        withArray* `[CInt]',
+        withArray* `[CInt]',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        withCStringArrayT* `[Text]',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        withArray* `[CUInt]',
+        withArray* `[CUInt]',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        withArray* `[CInt]',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        withArray* `[CInt]',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        id `Ptr CInt',                          -- [in/out] shared_buffer_len
+        id `Ptr (Ptr CChar)',                   -- [in, optional] shared_buffer_name_list
+        id `Ptr NDArrayHandlePtr',              -- [in, optional] shared_buffer_handle_list
+        alloca- `Ptr (Ptr CChar)' peek*,        -- [out] updated_shared_buffer_name_list
+        alloca- `Ptr NDArrayHandlePtr' peek*,   -- [out] updated_shared_buffer_handle_list
+        alloca- `CUInt' peek*,
+        alloca- `Ptr NDArrayHandlePtr' peek*,
+        alloca- `Ptr NDArrayHandlePtr' peek*,
+        alloca- `CUInt' peek*,
+        alloca- `Ptr NDArrayHandlePtr' peek*,
+        `ExecutorHandle',
+        alloca- `ExecutorHandle' peekExecutorHandle*
+    } -> `CInt'
+#}
+#endif
 
 mxExecutorSimpleBind :: SymbolHandle
                      -> Int -> Int                        -- device
-                     -> [String] -> [Int] -> [Int]        -- g2c
-                     -> [String] -> [String]              -- provided_grad_req_list
-                     -> [String] -> [Int] -> [Int]        -- provided_arg_shapes
-                     -> [String] -> [Int]                 -- provided_arg_dtypes
-                     -> [String] -> [Int]                 -- provided_arg_stypes
-                     -> [String]                          -- shared_arg_names
-                     -> Maybe ([String], [NDArrayHandle]) -- shared_buffer
+                     -> [Text] -> [Int] -> [Int]        -- g2c
+                     -> [Text] -> [Text]              -- provided_grad_req_list
+                     -> [Text] -> [Int] -> [Int]        -- provided_arg_shapes
+                     -> [Text] -> [Int]                 -- provided_arg_dtypes
+                     -> [Text] -> [Int]                 -- provided_arg_stypes
+                     -> [Text]                          -- shared_arg_names
+                     -> Maybe ([Text], [NDArrayHandle]) -- shared_buffer
                      -> ExecutorHandle                    -- shared_exec_handle
-                     -> IO (Maybe ([String], [NDArrayHandle]), -- updated_shared_buffer
+                     -> IO (Maybe ([Text], [NDArrayHandle]), -- updated_shared_buffer
                             [NDArrayHandle],                   -- arg_array
                             [NDArrayHandle],                   -- grad_array
                             [NDArrayHandle],                   -- aux_array
                             ExecutorHandle)
-mxExecutorSimpleBind symbol 
-                     devtype devid 
-                     g2c_keys g2c_dev_types g2c_dev_ids 
-                     provided_grad_req_names 
-                     provided_grad_req_types 
+mxExecutorSimpleBind symbol
+                     devtype devid
+                     g2c_keys g2c_dev_types g2c_dev_ids
+                     provided_grad_req_names
+                     provided_grad_req_types
                      provided_arg_shape_names provided_arg_shape_data provided_arg_shape_idx
-                     provided_arg_dtype_names provided_arg_dtypes 
-                     provided_arg_stype_names provided_arg_stypes 
-                     shared_arg_name_list 
-                     shared_buffer 
+                     provided_arg_dtype_names provided_arg_dtypes
+                     provided_arg_stype_names provided_arg_stypes
+                     shared_arg_name_list
+                     shared_buffer
                      shared_exec_handle =
-    case shared_buffer of 
+    case shared_buffer of
 
         Nothing -> alloca (\ptr_shared_buffer_len -> do
             poke ptr_shared_buffer_len (-1)
-            (_, _, num_in_args, in_args, arg_grads, num_aux_states, aux_states, out) <- checked $ mxExecutorSimpleBind_ 
-                        symbol devtype_ devid_ 
-                        cnt_g2c g2c_keys g2c_dev_types_ g2c_dev_ids_ 
-                        cnt_provided_grad_req_list provided_grad_req_names provided_grad_req_types 
+            (_, _, num_in_args, in_args, arg_grads, num_aux_states, aux_states, out) <- checked $ mxExecutorSimpleBind_
+                        symbol devtype_ devid_
+                        cnt_g2c g2c_keys g2c_dev_types_ g2c_dev_ids_
+                        cnt_provided_grad_req_list provided_grad_req_names provided_grad_req_types
                         cnt_provided_arg_shapes provided_arg_shape_names provided_arg_shape_data_ provided_arg_shape_idx_
                         cnt_provided_arg_dtypes provided_arg_dtype_names provided_arg_dtypes_
                         cnt_provided_arg_stypes provided_arg_stype_names provided_arg_stypes_
@@ -343,12 +472,12 @@
 
         Just (shared_buffer_name_list, shared_buffer_handle_list) -> alloca (\ptr_shared_buffer_len -> do
             poke ptr_shared_buffer_len (fromIntegral $ length shared_buffer_name_list)
-            withStringArray shared_buffer_name_list (\ptr_shared_buffer_name_list -> 
+            withCStringArrayT shared_buffer_name_list (\ptr_shared_buffer_name_list ->
                 withNDArrayHandleArray shared_buffer_handle_list (\ptr_shared_buffer_handle_list -> do
-                    (ptr_updated_shared_buffer_name_list, ptr_updated_shared_buffer_handle_list, num_in_args, in_args, arg_grads, num_aux_states, aux_states, out) <- checked $ mxExecutorSimpleBind_ 
-                                symbol devtype_ devid_ 
-                                cnt_g2c g2c_keys g2c_dev_types_ g2c_dev_ids_ 
-                                cnt_provided_grad_req_list provided_grad_req_names provided_grad_req_types 
+                    (ptr_updated_shared_buffer_name_list, ptr_updated_shared_buffer_handle_list, num_in_args, in_args, arg_grads, num_aux_states, aux_states, out) <- checked $ mxExecutorSimpleBind_
+                                symbol devtype_ devid_
+                                cnt_g2c g2c_keys g2c_dev_types_ g2c_dev_ids_
+                                cnt_provided_grad_req_list provided_grad_req_names provided_grad_req_types
                                 cnt_provided_arg_shapes provided_arg_shape_names provided_arg_shape_data_ provided_arg_shape_idx_
                                 cnt_provided_arg_dtypes provided_arg_dtype_names provided_arg_dtypes_
                                 cnt_provided_arg_stypes provided_arg_stype_names provided_arg_stypes_
@@ -359,7 +488,7 @@
                     grad_array <- peekArray (fromIntegral num_in_args) arg_grads >>= mapM newNDArrayHandle
                     aux_array  <- peekArray (fromIntegral num_aux_states) aux_states >>= mapM newNDArrayHandle
                     update_shared_buffer_len <- fromIntegral <$> peek ptr_shared_buffer_len
-                    updated_shared_buffer_name_list <- peekStringArray update_shared_buffer_len ptr_updated_shared_buffer_name_list
+                    updated_shared_buffer_name_list <- peekCStringArrayT update_shared_buffer_len ptr_updated_shared_buffer_name_list
                     updated_shared_buffer_handle_list <- peekArray update_shared_buffer_len ptr_updated_shared_buffer_handle_list >>= mapM newNDArrayHandle
                     return (Just (updated_shared_buffer_name_list, updated_shared_buffer_handle_list), arg_array, grad_array, aux_array, out)
                 )))
@@ -380,35 +509,109 @@
     provided_arg_stypes_ = map fromIntegral $ provided_arg_stypes
     cnt_shared_arg_names = fromIntegral $ length shared_arg_name_list
 
--- {#
--- fun MXExecutorReshape as mxExecutorReshape_
---     {
---         `CInt',
---         `CInt',
---         `CInt',
---         `CInt',
---         `MX_UINT',
---         withStringArray* `[String]',
---         withArray* `[CInt]',
---         withArray* `[CInt]',
---         `MX_UINT',
---         withStringArray* `[String]',
---         withArray* `[MX_UINT]',
---         withArray* `[MX_UINT]',
---         alloca- `MX_UINT' peek*,
---         alloca- `Ptr NDArrayHandlePtr' peek*,
---         alloca- `Ptr NDArrayHandlePtr' peek*,
---         alloca- `MX_UINT' peek*,
---         alloca- `Ptr NDArrayHandlePtr' peek*,
---         `ExecutorHandle',
---         alloca- `ExecutorHandle' peekExecutorHandle*
---     } -> `CInt'
--- #}
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
+{#
+fun MXExecutorReshapeEx as mxExecutorReshapeEx_
+    {
+        `CInt',
+        `CInt',
+        `CInt',
+        `CInt',
+        `MX_UINT',
+        withCStringArrayT* `[Text]',
+        withArray* `[CInt]',
+        withArray* `[CInt]',
+        `MX_UINT',
+        withCStringArrayT* `[Text]',
+        withArray* `[CInt]',
+        withArray* `[MX_UINT]',
+        alloca0- `MX_UINT' peek*,
+        alloca- `Ptr NDArrayHandlePtr' peek*,
+        alloca- `Ptr NDArrayHandlePtr' peek*,
+        alloca0- `MX_UINT' peek*,
+        alloca- `Ptr NDArrayHandlePtr' peek*,
+        `ExecutorHandle',
+        alloca- `ExecutorHandle' peekExecutorHandle*
+    } -> `CInt'
+#}
+#else
+{#
+fun MXExecutorReshapeEx as mxExecutorReshapeEx_
+    {
+        `CInt',
+        `CInt',
+        `CInt',
+        `CInt',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        withArray* `[CInt]',
+        withArray* `[CInt]',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        withArray* `[CInt]',
+        withArray* `[CUInt]',
+        alloca0- `CUInt' peek*,
+        alloca- `Ptr NDArrayHandlePtr' peek*,
+        alloca- `Ptr NDArrayHandlePtr' peek*,
+        alloca0- `CUInt' peek*,
+        alloca- `Ptr NDArrayHandlePtr' peek*,
+        `ExecutorHandle',
+        alloca- `ExecutorHandle' peekExecutorHandle*
+    } -> `CInt'
+#}
+#endif
 
--- {# 
+mxExecutorReshapeEx :: Bool -> Bool -> Int -> Int
+                    -> [Text] -> [Int] -> [Int]        -- group2ctx
+                    -> [Text] -> [Int] -> [Int]        -- provided_arg_shapes
+                    -> ExecutorHandle                    -- shared exec
+                    -> IO ([NDArrayHandle], [Maybe NDArrayHandle], [NDArrayHandle], ExecutorHandle)
+mxExecutorReshapeEx partial_shaping allow_up_sizing
+                    devtype devid
+                    g2c_keys g2c_dev_types g2c_dev_ids
+                    provided_arg_shape_names provided_arg_shape_data provided_arg_shape_idx
+                    shared_exec_handler = do
+    (num_in, arr_in, arr_grad, num_aux, arr_aux, exec_hdl) <- checked $ mxExecutorReshapeEx_
+                    partial_shaping_ allow_up_sizing_
+                    devtype_ devid_
+                    cnt_g2c g2c_keys g2c_dev_types_ g2c_dev_ids_
+                    cnt_provided_arg_shapes provided_arg_shape_names provided_arg_shape_data_ provided_arg_shape_idx_
+                    shared_exec_handler
+
+    handle_ptrs <- peekArray (fromIntegral num_in) arr_in
+    arr_in   <- mapM newNDArrayHandle handle_ptrs
+
+    handle_ptrs <- peekArray (fromIntegral num_in) arr_grad
+    arr_grad <- flip mapM handle_ptrs $ \ptr ->
+                    if ptr == nullPtr
+                    then return Nothing
+                    else Just <$> newNDArrayHandle ptr
+
+    handle_ptrs <- peekArray (fromIntegral num_aux) arr_aux
+    arr_aux  <- mapM newNDArrayHandle handle_ptrs
+
+    return (arr_in, arr_grad, arr_aux, exec_hdl)
+  where
+    partial_shaping_ = if partial_shaping then 1 else 0
+    allow_up_sizing_ = if allow_up_sizing then 1 else 0
+    devtype_ = fromIntegral devtype
+    devid_ = fromIntegral devid
+
+    cnt_g2c = fromIntegral $ length g2c_keys
+    g2c_dev_types_ = map fromIntegral g2c_dev_types
+    g2c_dev_ids_ = map fromIntegral g2c_dev_ids
+
+    cnt_provided_arg_shapes = fromIntegral $ length provided_arg_shape_names
+    provided_arg_shape_data_ = map fromIntegral provided_arg_shape_data
+    provided_arg_shape_idx_  = map fromIntegral provided_arg_shape_idx
+
+-- {#
 -- fun MXExecutorGetOptimizedSymbol as mxExecutorGetOptimizedSymbol_
 --     {
 --         `ExecutorHandle',
 --         alloca- `SymbolHandle' peekSymbolHandle*
 --     } -> `CInt'
 -- #}
+
+alloca0 :: (Storable a, Num a) => (Ptr a -> IO b) -> IO b
+alloca0 f = alloca (\ptr -> poke ptr 0 >> f ptr)
diff --git a/c-apis/MXNet/Base/Raw/NDArray.chs b/c-apis/MXNet/Base/Raw/NDArray.chs
--- a/c-apis/MXNet/Base/Raw/NDArray.chs
+++ b/c-apis/MXNet/Base/Raw/NDArray.chs
@@ -1,15 +1,18 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 module MXNet.Base.Raw.NDArray where
 
+import RIO
+import RIO.List (unzip)
 import Foreign.Marshal (alloca, withArray, peekArray)
 import Foreign.Storable (Storable(..))
 import Foreign.Concurrent (newForeignPtr)
 import Foreign.ForeignPtr (touchForeignPtr)
 import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)
 import Foreign.C.Types
+import Foreign.C.String (CString)
 import Foreign.Ptr
-import C2HS.C.Extra.Marshal (withIntegralArray, peekStringArray)
 import GHC.Generics (Generic)
+import Control.DeepSeq (NFData(..), rwhnf)
 import Control.Monad ((>=>))
 
 {# import MXNet.Base.Raw.Common #}
@@ -23,11 +26,14 @@
 
 -- NDArray
 {#
-pointer NDArrayHandle foreign newtype 
+pointer NDArrayHandle foreign newtype
 #}
 
 deriving instance Generic NDArrayHandle
 deriving instance Show NDArrayHandle
+instance NFData NDArrayHandle where
+    rnf = rwhnf
+
 type NDArrayHandlePtr = Ptr NDArrayHandle
 
 touchNDArrayHandle :: NDArrayHandle -> IO ()
@@ -179,6 +185,7 @@
 mxNDArrayWaitAll :: IO ()
 mxNDArrayWaitAll = checked mxNDArrayWaitAll_
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXNDArraySlice as mxNDArraySlice_
     {
@@ -188,6 +195,17 @@
         alloca- `NDArrayHandle' peekNDArrayHandle*
     } -> `CInt'
 #}
+#else
+{#
+fun MXNDArraySlice as mxNDArraySlice_
+    {
+        `NDArrayHandle',
+        `CUInt',
+        `CUInt',
+        alloca- `NDArrayHandle' peekNDArrayHandle*
+    } -> `CInt'
+#}
+#endif
 
 mxNDArraySlice :: NDArrayHandle -> Int -> Int -> IO NDArrayHandle
 mxNDArraySlice array begin end = do
@@ -195,6 +213,8 @@
         end_   = fromIntegral end
     checked $ mxNDArraySlice_ array begin_ end_
 
+
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXNDArrayAt as mxNDArrayAt_
     {
@@ -203,6 +223,16 @@
         alloca- `NDArrayHandle' peekNDArrayHandle*
     } -> `CInt'
 #}
+#else
+{#
+fun MXNDArrayAt as mxNDArrayAt_
+    {
+        `NDArrayHandle',
+        `CUInt',
+        alloca- `NDArrayHandle' peekNDArrayHandle*
+    } -> `CInt'
+#}
+#endif
 
 mxNDArrayAt :: NDArrayHandle -> Int -> IO NDArrayHandle
 mxNDArrayAt array index = do
@@ -226,7 +256,7 @@
     {
         `NDArrayHandle',
         `CInt',
-        withIntegralArray* `[CInt]',
+        withArray* `[CInt]',
         alloca- `NDArrayHandle' peekNDArrayHandle*
     } -> `CInt'
 #}
@@ -253,7 +283,7 @@
     return $ fromIntegral <$> shape
 
 -- MXImperativeInvoke is hacky.
--- num-outputs 
+-- num-outputs
 --   0: create new NDArrayHandler in the array-of-NDArrayHandle
 --   length of array-of-NDArrayHandle (non-0): reuse NDArrayHandler in the array-of-NDArrayHandle
 {#
@@ -265,15 +295,16 @@
         id `Ptr CInt',                    -- num-outputs
         id `Ptr (Ptr NDArrayHandlePtr)',  -- array-of-NDArrayHandle
         `CInt',
-        withStringArray* `[String]',
-        withStringArray* `[String]'
+        withCStringArrayT* `[Text]',
+        withCStringArrayT* `[Text]'
     } -> `CInt'
 #}
 
 -- | Invoke a nnvm op and imperative function.
-mxImperativeInvoke :: AtomicSymbolCreator
+mxImperativeInvoke :: HasCallStack
+                   => AtomicSymbolCreator
                    -> [NDArrayHandle]
-                   -> [(String, String)]
+                   -> [(Text, Text)]
                    -> Maybe [NDArrayHandle]
                    -> IO [NDArrayHandle]
 mxImperativeInvoke creator inputs params outputs = do
@@ -288,7 +319,7 @@
                 checked $ mxImperativeInvoke_ creator ninput inputs pn pp nparam keys values
                 n' <- peek pn
                 p' <- peek pp
-                if n' == 0 
+                if n' == 0
                     then return []
                     else do
                         pa <- peekArray (fromIntegral n') (p' :: Ptr NDArrayHandlePtr)
@@ -317,17 +348,29 @@
     return (fromIntegral devtyp, fromIntegral devidx)
 
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
-fun MXNDArraySave as mxNDArraySave_ 
+fun MXNDArraySave as mxNDArraySave_
     {
-        `String',
+        withCStringT* `Text',
         `MX_UINT',
         withNDArrayHandleArray* `[NDArrayHandle]',
-        withStringArray* `[String]'
+        withCStringArrayT* `[Text]'
     } -> `CInt'
 #}
+#else
+{#
+fun MXNDArraySave as mxNDArraySave_
+    {
+        withCStringT* `Text',
+        `CUInt',
+        withNDArrayHandleArray* `[NDArrayHandle]',
+        withCStringArrayT* `[Text]'
+    } -> `CInt'
+#}
+#endif
 
-mxNDArraySave ::  String -> [(String, NDArrayHandle)] -> IO ()
+mxNDArraySave ::  Text -> [(Text, NDArrayHandle)] -> IO ()
 mxNDArraySave filename keyvals = do
     let num = length keyvals
         (keys, vals) = unzip keyvals
@@ -336,18 +379,18 @@
 {#
 fun MXNDArrayLoad as mxNDArrayLoad_
     {
-        `String',
+        withCStringT* `Text',
         alloca- `MX_UINT' peek*,
         alloca- `Ptr NDArrayHandlePtr' peek*,
         alloca- `MX_UINT' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*
+        alloca- `Ptr CString' peek*
     } -> `CInt'
 #}
 
-mxNDArrayLoad :: String -> IO [(String, NDArrayHandle)]
+mxNDArrayLoad :: Text -> IO [(Text, NDArrayHandle)]
 mxNDArrayLoad path = do
     (numArrays, ptrArrays, numNames, ptrNames) <- checked $ mxNDArrayLoad_ path
     pa <- peekArray (fromIntegral numArrays) ptrArrays
     arrays <- mapM newNDArrayHandle pa
-    names <- peekStringArray numNames ptrNames
+    names <- peekCStringArrayT (fromIntegral numNames) ptrNames
     return $ zip names arrays
diff --git a/c-apis/MXNet/Base/Raw/Symbol.chs b/c-apis/MXNet/Base/Raw/Symbol.chs
--- a/c-apis/MXNet/Base/Raw/Symbol.chs
+++ b/c-apis/MXNet/Base/Raw/Symbol.chs
@@ -1,18 +1,21 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 module MXNet.Base.Raw.Symbol where
 
+import RIO
+import qualified RIO.Text as T
+import qualified RIO.HashMap as M
+import qualified RIO.Vector.Boxed as VB
+import qualified RIO.Vector.Boxed.Partial as VB
+import Control.Lens ((?~), at, non)
 import Foreign.Marshal (alloca, withArray, peekArray, allocaBytesAligned)
 import Foreign.Storable (Storable(..))
 import Foreign.Ptr (FunPtr)
 import Foreign.C.Types
-import Foreign.C.String
+import Foreign.C.String (CString)
 import Foreign.Ptr
 import Foreign.Concurrent (newForeignPtr)
 import Foreign.ForeignPtr (touchForeignPtr)
 import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)
-import C2HS.C.Extra.Marshal (withIntegralArray, peekIntegralArray, peekString, peekStringArray)
-import GHC.Generics (Generic)
-import Control.Monad ((>=>))
 
 {# import MXNet.Base.Raw.Common #}
 {# import MXNet.Base.Raw.NDArray #}
@@ -58,20 +61,33 @@
 mxSymbolFree :: SymbolHandlePtr -> IO ()
 mxSymbolFree = checked . mxSymbolFree_
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXSymbolCreateAtomicSymbol as mxSymbolCreateAtomicSymbol_
     {
         `AtomicSymbolCreator',
         `MX_UINT',
-        withStringArray* `[String]',
-        withStringArray* `[String]',
+        withCStringArrayT* `[Text]',
+        withCStringArrayT* `[Text]',
         alloca- `SymbolHandle' peekSymbolHandle*
     } -> `CInt'
 #}
+#else
+{#
+fun MXSymbolCreateAtomicSymbol as mxSymbolCreateAtomicSymbol_
+    {
+        `AtomicSymbolCreator',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        withCStringArrayT* `[Text]',
+        alloca- `SymbolHandle' peekSymbolHandle*
+    } -> `CInt'
+#}
+#endif
 
 mxSymbolCreateAtomicSymbol :: AtomicSymbolCreator
-                           -> [String]
-                           -> [String]
+                           -> [Text]
+                           -> [Text]
                            -> IO SymbolHandle
 mxSymbolCreateAtomicSymbol creator keys vals = do
     let argcnt = fromIntegral $ length keys
@@ -80,14 +96,15 @@
 {#
 fun MXSymbolCreateVariable as mxSymbolCreateVariable_
     {
-        `String',
+        withCStringT* `Text',
         alloca- `SymbolHandle' peekSymbolHandle*
     } -> `CInt'
 #}
 
-mxSymbolCreateVariable :: String -> IO SymbolHandle
+mxSymbolCreateVariable :: Text -> IO SymbolHandle
 mxSymbolCreateVariable = checked . mxSymbolCreateVariable_
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXSymbolCreateGroup as mxSymbolCreateGroup_
     {
@@ -96,6 +113,16 @@
         alloca- `SymbolHandle' peekSymbolHandle*
     } -> `CInt'
 #}
+#else
+{#
+fun MXSymbolCreateGroup as mxSymbolCreateGroup_
+    {
+        `CUInt',
+        withSymbolHandleArray* `[SymbolHandle]',
+        alloca- `SymbolHandle' peekSymbolHandle*
+    } -> `CInt'
+#}
+#endif
 
 mxSymbolCreateGroup :: [SymbolHandle] -> IO SymbolHandle
 mxSymbolCreateGroup syms = checked $ mxSymbolCreateGroup_ (fromIntegral $ length syms) syms
@@ -103,24 +130,24 @@
 {#
 fun MXSymbolCreateFromJSON as mxSymbolCreateFromJSON_
     {
-        `String',
+        withCStringT* `Text',
         alloca- `SymbolHandle' peekSymbolHandle*
     } -> `CInt'
 #}
 
-mxSymbolCreateFromJSON :: String -> IO SymbolHandle
+mxSymbolCreateFromJSON :: Text -> IO SymbolHandle
 mxSymbolCreateFromJSON = checked . mxSymbolCreateFromJSON_
 
 {#
 fun MXSymbolSaveToJSON as mxSymbolSaveToJSON_
     {
         `SymbolHandle',
-        alloca- `String' peekString*
+        alloca- `Text' peekCStringPtrT*
     } -> `CInt'
 #}
 
-mxSymbolSaveToJSON :: SymbolHandle -> IO String
-mxSymbolSaveToJSON = checked . mxSymbolSaveToJSON_
+mxSymbolSaveToJSON :: SymbolHandle -> IO Text
+mxSymbolSaveToJSON = fmap unWrapText . checked . fmap (second WrapText) . mxSymbolSaveToJSON_
 
 {#
 fun MXSymbolCopy as mxSymbolCopy_
@@ -137,27 +164,27 @@
 fun MXSymbolPrint as mxSymbolPrint_
     {
         `SymbolHandle',
-        alloca- `String' peekString*
+        alloca- `Text' peekCStringPtrT*
     } -> `CInt'
 #}
 
-mxSymbolPrint :: SymbolHandle -> IO String
-mxSymbolPrint = checked . mxSymbolPrint_
+mxSymbolPrint :: SymbolHandle -> IO Text
+mxSymbolPrint = fmap unWrapText . checked . fmap (second WrapText) . mxSymbolPrint_
 
 {#
 fun MXSymbolGetName as mxSymbolGetName_
     {
         `SymbolHandle',
-        alloca- `Ptr (Ptr CChar)' id,
+        alloca- `Ptr CString' id,
         alloca- `CInt' peek*
     } -> `CInt'
 #}
 
-mxSymbolGetName :: SymbolHandle -> IO (Maybe String)
+mxSymbolGetName :: SymbolHandle -> IO (Maybe Text)
 mxSymbolGetName symbol = do
     (out, succ) <- checked $ mxSymbolGetName_ symbol
     if succ == 0 then
-        Just <$> peekString out
+        Just <$> peekCStringPtrT out
     else
         return Nothing
 
@@ -165,19 +192,19 @@
 fun MXSymbolGetAttr as mxSymbolGetAttr_
     {
         `SymbolHandle',
-        `String',
-        alloca- `Ptr (Ptr CChar)' id,
+        withCStringT* `Text',
+        alloca- `Ptr CString' id,
         alloca- `CInt' peek*
     } -> `CInt'
 #}
 
 mxSymbolGetAttr :: SymbolHandle
-                -> String
-                -> IO (Maybe String)
+                -> Text
+                -> IO (Maybe Text)
 mxSymbolGetAttr symbol key = do
     (pstr, succ) <- checked $ mxSymbolGetAttr_ symbol key
     if succ == 0 then
-        Just <$> peekString pstr
+        Just <$> peekCStringPtrT pstr
     else
         return Nothing
 
@@ -185,14 +212,14 @@
 fun MXSymbolSetAttr as mxSymbolSetAttr_
     {
         `SymbolHandle',
-        `String',
-        `String'
+        withCStringT* `Text',
+        withCStringT* `Text'
     } -> `CInt'
 #}
 
 mxSymbolSetAttr :: SymbolHandle
-                -> String
-                -> String
+                -> Text
+                -> Text
                 -> IO ()
 mxSymbolSetAttr symbol key val = checked $ mxSymbolSetAttr_ symbol key val
 
@@ -201,60 +228,75 @@
     {
         `SymbolHandle',
         alloca- `MX_UINT' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*
+        alloca- `Ptr CString' peek*
     } -> `CInt'
 #}
 
 mxSymbolListAttr :: SymbolHandle
-                 -> IO [String]
+                 -> IO (HashMap Text (HashMap Text Text))
 mxSymbolListAttr symbol = do
     (cnt, ptr) <- checked $ mxSymbolListAttr_ symbol
-    peekStringArray (fromIntegral cnt) ptr
+    cnt <- pure $ fromIntegral cnt
+    kvs <- VB.fromList <$> peekCStringArrayT (2 * cnt) ptr
+    let kv_tuples = map (\i -> let p = i * 2
+                                   q = p + 1
+                               in (kvs VB.! p, kvs VB.! q))
+                        [0..cnt-1]
+        upd m (k, v) = case T.split (=='$') k of
+                         [k1, k2] -> m & at k1 . non M.empty . at k2 ?~ v
+                         _ -> error ("bad attr " ++ T.unpack k)
+    return $ foldl' upd M.empty kv_tuples
 
 {#
 fun MXSymbolListAttrShallow as mxSymbolListAttrShallow_
     {
         `SymbolHandle',
         alloca- `MX_UINT' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*
+        alloca- `Ptr CString' peek*
     } -> `CInt'
 #}
 
 mxSymbolListAttrShallow :: SymbolHandle
-                        -> IO [String]
+                        -> IO (HashMap Text Text)
 mxSymbolListAttrShallow symbol = do
     (cnt, ptr) <- checked $ mxSymbolListAttrShallow_ symbol
-    peekStringArray (fromIntegral cnt) ptr
+    cnt <- pure $ fromIntegral cnt
+    kvs <- VB.fromList <$> peekCStringArrayT (2 * fromIntegral cnt) ptr
+    let kv_tuples = map (\i -> let p = i * 2
+                                   q = p + 1
+                               in (kvs VB.! p, kvs VB.! q))
+                        [0..cnt-1]
+    return $ M.fromList kv_tuples
 
 {#
 fun MXSymbolListArguments as mxSymbolListArguments_
     {
         `SymbolHandle',
         alloca- `MX_UINT' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*
+        alloca- `Ptr CString' peek*
     } -> `CInt'
 #}
 
 mxSymbolListArguments :: SymbolHandle
-                      -> IO [String]
+                      -> IO [Text]
 mxSymbolListArguments symbol = do
     (cnt, ptr) <- checked $ mxSymbolListArguments_ symbol
-    peekStringArray (fromIntegral cnt) ptr
+    peekCStringArrayT (fromIntegral cnt) ptr
 
 {#
 fun MXSymbolListOutputs as mxSymbolListOutputs_
     {
         `SymbolHandle',
         alloca- `MX_UINT' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*
+        alloca- `Ptr CString' peek*
     } -> `CInt'
 #}
 
 mxSymbolListOutputs :: SymbolHandle
-                    -> IO [String]
+                    -> IO [Text]
 mxSymbolListOutputs symbol = do
     (cnt, ptr) <- checked $ mxSymbolListOutputs_ symbol
-    peekStringArray (fromIntegral cnt) ptr
+    peekCStringArrayT (fromIntegral cnt) ptr
 
 {#
 fun MXSymbolGetInternals as mxSymbolGetInternals_
@@ -278,6 +320,7 @@
 mxSymbolGetChildren :: SymbolHandle -> IO SymbolHandle
 mxSymbolGetChildren = checked . mxSymbolGetChildren_
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXSymbolGetOutput as mxSymbolGetOutput_
     {
@@ -286,6 +329,17 @@
         alloca- `SymbolHandle' peekSymbolHandle*
     } -> `CInt'
 #}
+#else
+{#
+fun MXSymbolGetOutput as mxSymbolGetOutput_
+    {
+        `SymbolHandle',
+        `CUInt',
+        alloca- `SymbolHandle' peekSymbolHandle*
+    } -> `CInt'
+#}
+#endif
+
 mxSymbolGetOutput :: SymbolHandle
                    -> Int
                    -> IO SymbolHandle
@@ -297,42 +351,56 @@
     {
         `SymbolHandle',
         alloca- `MX_UINT' peek*,
-        alloca- `Ptr (Ptr CChar)' peek*
+        alloca- `Ptr CString' peek*
     } -> `CInt'
 #}
-mxSymbolListAuxiliaryStates :: SymbolHandle -> IO [String]
+mxSymbolListAuxiliaryStates :: SymbolHandle -> IO [Text]
 mxSymbolListAuxiliaryStates symbol = do
     (cnt, ptr) <- checked $ mxSymbolListAuxiliaryStates_ symbol
-    peekStringArray (fromIntegral cnt) ptr
+    peekCStringArrayT (fromIntegral cnt) ptr
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXSymbolCompose as mxSymbolCompose_
     {
         `SymbolHandle',
-        `String',
+        `Text',
         `MX_UINT',
-        id `Ptr (Ptr CChar)',
+        id `Ptr CString',
         withSymbolHandleArray* `[SymbolHandle]'
     } -> `CInt'
 #}
+#else
+{#
+fun MXSymbolCompose as mxSymbolCompose_
+    {
+        `SymbolHandle',
+        withCStringT* `Text',
+        `CUInt',
+        id `Ptr CString',
+        withSymbolHandleArray* `[SymbolHandle]'
+    } -> `CInt'
+#}
+#endif
 
 mxSymbolCompose :: SymbolHandle
-                -> String
-                -> Maybe [String]
+                -> Text
+                -> Maybe [Text]
                 -> [SymbolHandle]
                 -> IO ()
 mxSymbolCompose symbol name maybekeys args = do
     let len = fromIntegral $ length args
     case maybekeys of
       Nothing -> checked $ mxSymbolCompose_ symbol name len C2HSImp.nullPtr args
-      Just keys -> withStringArray keys $ \pkeys -> checked $ mxSymbolCompose_ symbol name len pkeys args
+      Just keys -> withCStringArrayT keys $ \pkeys -> checked $ mxSymbolCompose_ symbol name len pkeys args
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXSymbolInferShape as mxSymbolInferShape_
     {
         `SymbolHandle',
         `MX_UINT',
-        withStringArray* `[String]',
+        withCStringArrayT* `[Text]',
         withArray* `[MX_UINT]',
         withArray* `[MX_UINT]',
         alloca- `MX_UINT' peek*,
@@ -347,9 +415,31 @@
         alloca- `CInt' peek*
     } -> `CInt'
 #}
+#else
+{#
+fun MXSymbolInferShape as mxSymbolInferShape_
+    {
+        `SymbolHandle',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        withArray* `[CUInt]',
+        withArray* `[CUInt]',
+        alloca- `CUInt' peek*,
+        alloca- `Ptr CUInt' peek*,
+        alloca- `Ptr (Ptr CUInt)' peek*,
+        alloca- `CUInt' peek*,
+        alloca- `Ptr CUInt' peek*,
+        alloca- `Ptr (Ptr CUInt)' peek*,
+        alloca- `CUInt' peek*,
+        alloca- `Ptr CUInt' peek*,
+        alloca- `Ptr (Ptr CUInt)' peek*,
+        alloca- `CInt' peek*
+    } -> `CInt'
+#}
+#endif
 
 mxSymbolInferShape :: SymbolHandle
-                   -> [String]
+                   -> [Text]
                    -> [Int]
                    -> [Int]
                    -> IO ([[Int]], [[Int]], [[Int]], Bool)
@@ -362,25 +452,26 @@
      auxshape_size, auxshape_ndim, auxshape_data,
      complete) <- checked $ mxSymbolInferShape_ symbol num_args' keys arg_ind' arg_shape'
     let inshape_size' = fromIntegral inshape_size
-    inshape_ndim'    <- peekArray inshape_size' inshape_ndim
+    inshape_ndim'    <- map fromIntegral <$> peekArray inshape_size' inshape_ndim
     inshape_data'    <- peekArray inshape_size' inshape_data
-    inshape_data_ret <- mapM (uncurry peekArrayOfUInt) (zip inshape_ndim' inshape_data')
+    inshape_data_ret <- mapM (uncurry peekArrayAsIntegral) (zip inshape_ndim' inshape_data')
     let outshape_size'= fromIntegral outshape_size
-    outshape_ndim'   <- peekArray outshape_size' outshape_ndim
+    outshape_ndim'   <- map fromIntegral <$> peekArray outshape_size' outshape_ndim
     outshape_data'   <- peekArray outshape_size' outshape_data
-    outshape_data_ret<- mapM (uncurry peekArrayOfUInt) (zip outshape_ndim' outshape_data')
+    outshape_data_ret<- mapM (uncurry peekArrayAsIntegral) (zip outshape_ndim' outshape_data')
     let auxshape_size'= fromIntegral auxshape_size
-    auxshape_ndim'   <- peekArray auxshape_size' auxshape_ndim
+    auxshape_ndim'   <- map fromIntegral <$> peekArray auxshape_size' auxshape_ndim
     auxshape_data'   <- peekArray auxshape_size' auxshape_data
-    auxshape_data_ret<- mapM (uncurry peekArrayOfUInt) (zip auxshape_ndim' auxshape_data')
+    auxshape_data_ret<- mapM (uncurry peekArrayAsIntegral) (zip auxshape_ndim' auxshape_data')
     return (inshape_data_ret, outshape_data_ret, auxshape_data_ret, complete == 1)
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXSymbolInferShapePartial as mxSymbolInferShapePartial_
     {
         `SymbolHandle',
         `MX_UINT',
-        withStringArray* `[String]',
+        withCStringArrayT* `[Text]',
         withArray* `[MX_UINT]',
         withArray* `[MX_UINT]',
         alloca- `MX_UINT' peek*,
@@ -395,9 +486,31 @@
         alloca- `CInt' peek*
     } -> `CInt'
 #}
+#else
+{#
+fun MXSymbolInferShapePartial as mxSymbolInferShapePartial_
+    {
+        `SymbolHandle',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        withArray* `[CUInt]',
+        withArray* `[CUInt]',
+        alloca- `CUInt' peek*,
+        alloca- `Ptr CUInt' peek*,
+        alloca- `Ptr (Ptr CUInt)' peek*,
+        alloca- `CUInt' peek*,
+        alloca- `Ptr CUInt' peek*,
+        alloca- `Ptr (Ptr CUInt)' peek*,
+        alloca- `CUInt' peek*,
+        alloca- `Ptr CUInt' peek*,
+        alloca- `Ptr (Ptr CUInt)' peek*,
+        alloca- `CInt' peek*
+    } -> `CInt'
+#}
+#endif
 
 mxSymbolInferShapePartial :: SymbolHandle
-                   -> [String]
+                   -> [Text]
                    -> [Int]
                    -> [Int]
                    -> IO ([[Int]], [[Int]], [[Int]], Bool)
@@ -410,27 +523,28 @@
      auxshape_size, auxshape_ndim, auxshape_data,
      complete) <- checked $ mxSymbolInferShapePartial_ symbol num_args' keys arg_ind' arg_shape'
     let inshape_size' = fromIntegral inshape_size
-    inshape_ndim'    <- peekArray inshape_size' inshape_ndim
+    inshape_ndim'    <- map fromIntegral <$> peekArray inshape_size' inshape_ndim
     inshape_data'    <- peekArray inshape_size' inshape_data
-    inshape_data_ret <- mapM (uncurry peekArrayOfUInt) (zip inshape_ndim' inshape_data')
+    inshape_data_ret <- mapM (uncurry peekArrayAsIntegral) (zip inshape_ndim' inshape_data')
     let outshape_size'= fromIntegral outshape_size
-    outshape_ndim'   <- peekArray outshape_size' outshape_ndim
+    outshape_ndim'   <- map fromIntegral <$> peekArray outshape_size' outshape_ndim
     outshape_data'   <- peekArray outshape_size' outshape_data
-    outshape_data_ret<- mapM (uncurry peekArrayOfUInt) (zip outshape_ndim' outshape_data')
+    outshape_data_ret<- mapM (uncurry peekArrayAsIntegral) (zip outshape_ndim' outshape_data')
     let auxshape_size'= fromIntegral auxshape_size
-    auxshape_ndim'   <- peekArray auxshape_size' auxshape_ndim
+    auxshape_ndim'   <- map fromIntegral <$> peekArray auxshape_size' auxshape_ndim
     auxshape_data'   <- peekArray auxshape_size' auxshape_data
-    auxshape_data_ret<- mapM (uncurry peekArrayOfUInt) (zip auxshape_ndim' auxshape_data')
+    auxshape_data_ret<- mapM (uncurry peekArrayAsIntegral) (zip auxshape_ndim' auxshape_data')
     return (inshape_data_ret, outshape_data_ret, auxshape_data_ret, complete == 1)
 
-peekArrayOfUInt cnt ptr = peekIntegralArray (fromIntegral cnt)  ptr
+peekArrayAsIntegral cnt ptr = map fromIntegral <$> peekArray (fromIntegral cnt) ptr
 
+#if MXNet_MAJOR==1 && MXNet_MINOR<6
 {#
 fun MXSymbolInferType as mxSymbolInferType_
     {
         `SymbolHandle',
         `MX_UINT',
-        withStringArray* `[String]',
+        withCStringArrayT* `[Text]',
         withArray* `[CInt]',
         alloca- `MX_UINT' peek*,
         alloca- `Ptr CInt' peek*,
@@ -441,9 +555,27 @@
         alloca- `CInt' peek*
     } -> `CInt'
 #}
+#else
+{#
+fun MXSymbolInferType as mxSymbolInferType_
+    {
+        `SymbolHandle',
+        `CUInt',
+        withCStringArrayT* `[Text]',
+        withArray* `[CInt]',
+        alloca- `MX_UINT' peek*,
+        alloca- `Ptr CInt' peek*,
+        alloca- `MX_UINT' peek*,
+        alloca- `Ptr CInt' peek*,
+        alloca- `MX_UINT' peek*,
+        alloca- `Ptr CInt' peek*,
+        alloca- `CInt' peek*
+    } -> `CInt'
+#}
+#endif
 
 mxSymbolInferType :: SymbolHandle
-                  -> [String]
+                  -> [Text]
                   -> [Int]
                   -> IO (Maybe ([Int], [Int], [Int]))
 mxSymbolInferType symbol keys arg_type = do
@@ -454,9 +586,9 @@
      auxshape_size, auxshape_data,
      succ) <- checked $ mxSymbolInferType_ symbol num_args keys arg_type'
     if succ == 0 then do
-        inshape_data_ret  <- peekIntegralArray (fromIntegral inshape_size)  inshape_data
-        outshape_data_ret <- peekIntegralArray (fromIntegral outshape_size) outshape_data
-        auxshape_data_ret <- peekIntegralArray (fromIntegral auxshape_size) auxshape_data
+        inshape_data_ret  <- peekArrayAsIntegral (fromIntegral inshape_size)  inshape_data
+        outshape_data_ret <- peekArrayAsIntegral (fromIntegral outshape_size) outshape_data
+        auxshape_data_ret <- peekArrayAsIntegral (fromIntegral auxshape_size) auxshape_data
         return $ Just (inshape_data_ret, outshape_data_ret, auxshape_data_ret)
     else
         return Nothing
@@ -465,11 +597,11 @@
 fun MXSymbolSaveToFile as mxSymbolSaveToFile_
     {
         `SymbolHandle',
-        `String'
+        withCStringT* `Text'
     } -> `CInt'
 #}
 
-mxSymbolSaveToFile :: String -> SymbolHandle -> IO ()
+mxSymbolSaveToFile :: Text -> SymbolHandle -> IO ()
 mxSymbolSaveToFile filename sym = do
     checked $ mxSymbolSaveToFile_ sym filename
 
@@ -517,12 +649,12 @@
 {#
 fun MXCustomOpRegister as mxCustomOpRegister_
     {
-        `String',
+        withCStringT* `Text',
         id `FunPtr CustomOpPropCreator'
     } -> `CInt'
 #}
 
-mxCustomOpRegister :: String -> FunPtr CustomOpPropCreator -> IO ()
+mxCustomOpRegister :: Text -> FunPtr CustomOpPropCreator -> IO ()
 mxCustomOpRegister op cr = checked $ mxCustomOpRegister_ op cr
 
 -- {#
diff --git a/c-apis/MXNet/Base/Spec/HMap.hs b/c-apis/MXNet/Base/Spec/HMap.hs
--- a/c-apis/MXNet/Base/Spec/HMap.hs
+++ b/c-apis/MXNet/Base/Spec/HMap.hs
@@ -8,10 +8,10 @@
 {-# LANGUAGE ConstraintKinds #-}
 module MXNet.Base.Spec.HMap where
 
+import RIO
 import GHC.TypeLits
 import Data.Proxy
 import Data.Typeable (Typeable)
-import Data.Maybe
 import Data.Constraint (Dict(..))
 import Type.Reflection (someTypeRep)
 import Unsafe.Coerce (unsafeCoerce)
@@ -24,7 +24,7 @@
   Nil  :: Pair p => HMap p '[]
   Cons :: Pair p => p k v -> HMap p kvs -> HMap p (p k v ': kvs)
 
-infixr 0 .& 
+infixr 0 .&
 kv .& other = Cons kv other
 
 class Access (b :: Bool) p k v kvs | k kvs -> v where
@@ -34,7 +34,7 @@
   get' _ (Cons pair _) _ = value pair
 
 instance Access (MatchHead p k v kvs) p k v kvs => Access False p k v (kv ': kvs) where
-  get' _ (Cons _ n) k = get' (Proxy :: Proxy (MatchHead p k v kvs)) n k  
+  get' _ (Cons _ n) k = get' (Proxy :: Proxy (MatchHead p k v kvs)) n k
 
 get :: forall p k v kvs. Access (MatchHead p k v kvs) p k v kvs => HMap p kvs -> Proxy k -> v
 get = get' (Proxy :: Proxy (MatchHead p k v kvs))
diff --git a/c-apis/MXNet/Base/Spec/Operator.hs b/c-apis/MXNet/Base/Spec/Operator.hs
--- a/c-apis/MXNet/Base/Spec/Operator.hs
+++ b/c-apis/MXNet/Base/Spec/Operator.hs
@@ -1,20 +1,26 @@
-{-# LANGUAGE OverloadedLabels  #-}
-{-# LANGUAGE PolyKinds, DataKinds, TypeFamilies #-}
-{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses #-}
-{-# LANGUAGE GADTs, TypeOperators #-}
-{-# LANGUAGE UndecidableInstances #-}
+{-# LANGUAGE ConstraintKinds       #-}
+{-# LANGUAGE DataKinds             #-}
+{-# LANGUAGE FlexibleInstances     #-}
+{-# LANGUAGE GADTs                 #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedLabels      #-}
 {-# LANGUAGE PartialTypeSignatures #-}
-{-# LANGUAGE ConstraintKinds #-}
-{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE PolyKinds             #-}
+{-# LANGUAGE ScopedTypeVariables   #-}
+{-# LANGUAGE TypeFamilies          #-}
+{-# LANGUAGE TypeOperators         #-}
+{-# LANGUAGE UndecidableInstances  #-}
 module MXNet.Base.Spec.Operator where
 
-import GHC.OverloadedLabels
-import GHC.TypeLits
-import GHC.Exts (Constraint)
-import Data.Proxy
-import Data.List (intersperse)
-import Data.Constraint
-import MXNet.Base.Spec.HMap
+import           Data.Constraint
+import           Data.Proxy
+import           GHC.Exts             (Constraint)
+import           GHC.OverloadedLabels
+import           GHC.TypeLits
+import           MXNet.Base.Spec.HMap
+import           RIO                  hiding (Text)
+import           RIO.List             (intersperse)
+import qualified RIO.Text             as RT
 
 instance a ~ b => IsLabel a (Proxy b) where
   fromLabel = Proxy
@@ -32,9 +38,9 @@
 
 instance (KnownSymbol v, HasEnum v e) => IsLabel v (EnumType e) where
     fromLabel = EnumType (Proxy :: Proxy v)
-  
+
 ----
-type family ParameterList (s :: Symbol) :: [(Symbol, Attr)]
+type family ParameterList (s :: Symbol) (t :: *) :: [(Symbol, Attr)]
 
 data Attr where
   AttrReq :: (a :: *) -> Attr
@@ -44,8 +50,8 @@
   ParameterType (AttrReq a) = a
   ParameterType (AttrOpt a) = a
 
-type family ResolveParameter (s :: Symbol) (k :: Symbol) :: Attr where
-  ResolveParameter s k = FindKey k (ParameterList s) (Text "Parameter '" :<>: 
+type family ResolveParameter (s :: Symbol) (t :: *) (k :: Symbol) :: Attr where
+  ResolveParameter s t k = FindKey k (ParameterList s t) (Text "Parameter '" :<>:
                               Text k :<>:
                               Text " not found")
 
@@ -56,11 +62,12 @@
 
 ----
 
-data ArgOf s k v where
-  (:=) :: (info ~ ResolveParameter s k) => Proxy k -> ParameterType info -> ArgOf s k (ParameterType info)
-  (:≅) :: Proxy k -> a -> ArgOf s k a
+data ArgOf s t k v where
+  (:=) :: (info ~ ResolveParameter s t k) => Proxy k -> ParameterType info -> ArgOf s t k (ParameterType info)
+  -- | (:≅) is an alternative of (:=) that bypasses the type check
+  (:≅) :: Proxy k -> a -> ArgOf s t k a
 
-instance Pair (ArgOf s) where
+instance Pair (ArgOf s t) where
   key   (k := v) = k
   key   (k :≅ v) = k
   value (k := v) = v
@@ -69,84 +76,90 @@
 infix 5 !, !?
 infix 1 :=, :≅
 
-(!) :: Access (MatchHead (ArgOf s) k v kvs) (ArgOf s) k v kvs 
-  => ArgsHMap s kvs -> Proxy k -> v
+(!) :: Access (MatchHead (ArgOf s t) k v kvs) (ArgOf s t) k v kvs
+  => ArgsHMap s t kvs -> Proxy k -> v
 (!) = get
 
-(!?) :: (ParameterType (ResolveParameter s k) ~ v, Query (MatchHead (ArgOf s) k v kvs) (ArgOf s) k v kvs) 
-  => ArgsHMap s kvs -> Proxy k -> Maybe v
+(!?) :: (ParameterType (ResolveParameter s t k) ~ v, Query (MatchHead (ArgOf s t) k v kvs) (ArgOf s t) k v kvs)
+  => ArgsHMap s t kvs -> Proxy k -> Maybe v
 (!?) = query
 
-type ArgsHMap s kvs = HMap (ArgOf s) kvs
+type ArgsHMap s t kvs = HMap (ArgOf s t) kvs
 ----
 class Value a where
-  showValue :: a -> String
+  showValue :: a -> RT.Text
 
 instance Value (EnumType e) where
-  showValue (EnumType v) = symbolVal v
+  showValue (EnumType v) = RT.pack $ symbolVal v
 
 instance Value Int where
-  showValue = show
+  showValue = tshow
 
 instance Value Bool where
-  showValue = show
+  showValue = tshow
 
 instance Value Float where
-  showValue = show
+  showValue = tshow
 
 instance Value Double where
-  showValue = show
+  showValue = tshow
 
+instance Value RT.Text where
+  showValue = id
+
 instance Value a => Value (Maybe a) where
-  showValue Nothing = "None"
+  showValue Nothing  = "None"
   showValue (Just a) = showValue a
-  
+
+instance (Value a, Value b) => Value (a, b) where
+  showValue (a, b) = RT.concat $ ["("] ++ [showValue a, ",", showValue b] ++ [")"]
+
 instance ValueList (IsChar a) [a] => Value [a] where
   showValue = showValueList (Proxy :: Proxy (IsChar a))
 
 class ValueList (str :: Bool) as where
-  showValueList :: Proxy str -> as -> String
+  showValueList :: Proxy str -> as -> RT.Text
 
 instance ValueList True String where
-  showValueList _ = id
+  showValueList _ = RT.pack
 
 instance Value a => ValueList False [a] where
-  showValueList _ as = "[" ++ concat (intersperse "," (map showValue as)) ++ "]"
+  showValueList _ as = RT.concat $ ["["] ++ intersperse "," (map showValue as) ++ ["]"]
 
 type family IsChar a :: Bool where
   IsChar Char = True
   IsChar x = False
 
 class Dump a where
-  dump :: a -> [(String, String)]
+  dump :: a -> [(RT.Text, RT.Text)]
 
-instance Dump (ArgsHMap s '[]) where
+instance Dump (ArgsHMap s t '[]) where
   dump = const []
 
-instance (Dump (ArgsHMap s kvs), KnownSymbol k, Value v) => Dump (ArgsHMap s (ArgOf s k v ': kvs)) where
-  dump (Cons (k := v) kvs) = (symbolVal k, showValue v) : dump kvs
-  dump (Cons (k :≅ v) kvs) = (symbolVal k, showValue v) : dump kvs
+instance (Dump (ArgsHMap s t kvs), KnownSymbol k, Value v) => Dump (ArgsHMap s t (ArgOf s t k v ': kvs)) where
+  dump (Cons (k := v) kvs) = (RT.pack $ symbolVal k, showValue v) : dump kvs
+  dump (Cons (k :≅ v) kvs) = (RT.pack $ symbolVal k, showValue v) : dump kvs
 
 ----
 type family Subset (s1 :: [(Symbol, *)]) (s2 :: [(Symbol, *)]) :: Constraint where
   Subset '[] _ = ()
-  Subset ('(a, t) ': s1) s2 = ( IfThenElse (HasElement '(a,t) s2) 
-                                  (() :: Constraint) 
+  Subset ('(a, t) ': s1) s2 = ( IfThenElse (HasElement '(a,t) s2)
+                                  (() :: Constraint)
                                   (TypeError (Text "Argument '" :<>: Text a :<>: Text "' is required."))
                               , Subset s1 s2)
   Subset a b = TypeError (Text "xx")
 
 type family AsKVs (a :: [*]) :: [(Symbol, *)] where
-  AsKVs (ArgOf s k v ': args) = '(k, v) ': AsKVs args
+  AsKVs (ArgOf s t k v ': args) = '(k, v) ': AsKVs args
   AsKVs '[] = '[]
 
-type family GenAccess s kvs (req :: [(Symbol, *)]) :: Constraint where
-  GenAccess s kvs '[] = ()
-  GenAccess s kvs ('(k, v) ': req) = (Access (MatchHead (ArgOf s) k v kvs) (ArgOf s) k v kvs, GenAccess s kvs req)
+type family GenAccess s t kvs (req :: [(Symbol, *)]) :: Constraint where
+  GenAccess s t kvs '[] = ()
+  GenAccess s t kvs ('(k, v) ': req) = (Access (MatchHead (ArgOf s t) k v kvs) (ArgOf s t) k v kvs, GenAccess s t kvs req)
 
-type family GenQuery  s kvs (req :: [(Symbol, *)]) :: Constraint where
-  GenQuery  s kvs '[]  = ()
-  GenQuery  s kvs ('(k, v) ': req) = (Query  (MatchHead (ArgOf s) k v kvs) (ArgOf s) k v kvs, GenQuery  s kvs req)
+type family GenQuery  s t kvs (req :: [(Symbol, *)]) :: Constraint where
+  GenQuery  s t kvs '[]  = ()
+  GenQuery  s t kvs ('(k, v) ': req) = (Query  (MatchHead (ArgOf s t) k v kvs) (ArgOf s t) k v kvs, GenQuery  s t kvs req)
 
 
 type family FilterRequired (pl :: [(k, Attr)]) :: [(k, *)] where
@@ -160,32 +173,32 @@
   AllArgs ('(s, AttrReq t) ': pl) = '(s,t) ': AllArgs pl
   AllArgs ('(s, AttrOpt t) ': pl) = '(s,t) ': AllArgs pl
 
-type family Fullfilled (s :: Symbol) (args :: [*]) :: Constraint where
-  Fullfilled s args = ( Subset ( FilterRequired (ParameterList s)) (AsKVs args)
-                      , GenAccess s args (FilterRequired (ParameterList s))
-                      , GenQuery  s args (AllArgs (ParameterList s)))
+type family Fullfilled (s :: Symbol) t (args :: [*]) :: Constraint where
+  Fullfilled s t args = ( Subset ( FilterRequired (ParameterList s t)) (AsKVs args)
+                        , GenAccess s t args (FilterRequired (ParameterList s t))
+                        , GenQuery  s t args (AllArgs (ParameterList s t)))
 
 -- type family HasOptArg (s :: Symbol) (args :: [*]) (k :: [Symbol]) :: Constraint where
 --   HasOptArg s args '[] = ()
---   HasOptArg s args (k0 ': ks) = ( Query (MatchHead (ArgOf s) k0 (ParameterType (ResolveParameter s k0)) args) 
---                                         (ArgOf s) 
---                                         k0 
---                                         (ParameterType (ResolveParameter s k0)) 
+--   HasOptArg s args (k0 ': ks) = ( Query (MatchHead (ArgOf s) k0 (ParameterType (ResolveParameter s k0)) args)
+--                                         (ArgOf s)
+--                                         k0
+--                                         (ParameterType (ResolveParameter s k0))
 --                                         args
 --                                 , HasOptArg s args ks)
 
 -- type family HasReqArg (s :: Symbol) (args :: [*]) (k :: [Symbol]) :: Constraint where
 --   HasReqArg s args '[] = ()
---   HasReqArg s args (k0 ': ks) = ( Access (MatchHead (ArgOf s) k0 (ParameterType (ResolveParameter s k0)) args) 
---                                         (ArgOf s) 
---                                         k0 
---                                         (ParameterType (ResolveParameter s k0)) 
+--   HasReqArg s args (k0 ': ks) = ( Access (MatchHead (ArgOf s) k0 (ParameterType (ResolveParameter s k0)) args)
+--                                         (ArgOf s)
+--                                         k0
+--                                         (ParameterType (ResolveParameter s k0))
 --                                         args
 --                                 , HasElement '(k0, ParameterType (ResolveParameter s k0)) (AsKVs args) ~ True
---                                 , Query  (MatchHead (ArgOf s) k0 (ParameterType (ResolveParameter s k0)) args) 
---                                         (ArgOf s) 
---                                         k0 
---                                         (ParameterType (ResolveParameter s k0)) 
+--                                 , Query  (MatchHead (ArgOf s) k0 (ParameterType (ResolveParameter s k0)) args)
+--                                         (ArgOf s)
+--                                         k0
+--                                         (ParameterType (ResolveParameter s k0))
 --                                         args
 --                                 , HasReqArg s args ks)
 
@@ -195,17 +208,17 @@
                                     ,HasElement '(k, t) (AsKVs args) ~ True
                                     ,Query (MatchHead p k t args) p k t args)
 
-type family HasArgs (s :: Symbol) (args :: [*]) (k :: [Symbol]) :: Constraint where
-  HasArgs s args '[] = ()
-  HasArgs s args (k0 ': ks) = (HasArgsGen (ArgOf s) (ResolveParameter s k0) k0 args, HasArgs s args ks)
+type family HasArgs (s :: Symbol) t (args :: [*]) (k :: [Symbol]) :: Constraint where
+  HasArgs s t args '[] = ()
+  HasArgs s t args (k0 ': ks) = (HasArgsGen (ArgOf s t) (ResolveParameter s t k0) k0 args, HasArgs s t args ks)
 
 type family WithoutArgsGen p t k args :: Constraint where
   WithoutArgsGen p t k args = (Query (MatchHead p k t args) p k t args
                               ,HasElement '(k, t) (AsKVs args) ~ False)
 
-type family WithoutArgs (s :: Symbol) (args :: [*]) (k :: [Symbol]) :: Constraint where
-  WithoutArgs s args '[] = ()
-  WithoutArgs s args (k0 ': ks) = (WithoutArgsGen (ArgOf s) (ParameterType (ResolveParameter s k0)) k0 args, WithoutArgs s args ks)
+type family WithoutArgs (s :: Symbol) t (args :: [*]) (k :: [Symbol]) :: Constraint where
+  WithoutArgs s t args '[] = ()
+  WithoutArgs s t args (k0 ': ks) = (WithoutArgsGen (ArgOf s t) (ParameterType (ResolveParameter s t k0)) k0 args, WithoutArgs s t args ks)
 ----
 type family HasElement (s :: k) (l :: [k]) :: Bool where
   HasElement s (s ': _) = True
@@ -218,36 +231,36 @@
 
 -------------------------------------
 
-type instance ParameterList "fn" = [
-  '("a", AttrReq Int), 
+type instance ParameterList "fn" t = [
+  '("a", AttrReq Int),
   '("b", AttrOpt String),
   '("c", AttrReq (EnumType '["c1","c2"])),
   '("d", AttrOpt (Maybe (EnumType '["c1","c2"])))
   ]
-args1 :: ArgsHMap "fn" _
+args1 :: ArgsHMap "fn" _ _
 args1 = Nil
 
-args2 :: ArgsHMap "fn" _
+args2 :: ArgsHMap "fn" _ _
 args2 = #a := 3 .& Nil
 
-args3 :: ArgsHMap "fn" _
+args3 :: ArgsHMap "fn" _ _
 args3 = #a := 3 .& #b := "Hello" .& Nil
 
-args4 :: ArgsHMap "fn" _
+args4 :: ArgsHMap "fn" _ _
 args4 = #a := 3 .& #c := #c1 .& Nil
 
-args5 :: ArgsHMap "fn" _
+args5 :: ArgsHMap "fn" _ _
 args5 = #a := 3 .& #c := #c1 .& #d := Just #c2 .& Nil
 
-fn1 :: Fullfilled "fn" args => ArgsHMap "fn" args -> _
+fn1 :: Fullfilled "fn" t args => ArgsHMap "fn" t args -> _
 fn1 args = args !? #b
 
-fn2 :: GenQuery "fn" args '[ '("b", String), '("d", (Maybe (EnumType '["c1","c2"])))]
-    => ArgsHMap "fn" args -> _
+fn2 :: GenQuery "fn" t args '[ '("b", String), '("d", (Maybe (EnumType '["c1","c2"])))]
+    => ArgsHMap "fn" t args -> _
 fn2 args = fn1 (#a := 3 .& #c := #c1 .& args)
 
-fn3 :: (HasArgs "fn" args '["b", "c", "d"]) => ArgsHMap "fn" args -> _
+fn3 :: (HasArgs "fn" t args '["b", "c", "d"]) => ArgsHMap "fn" t args -> _
 fn3 args = fn1 (#a := 3 .& args)
 
-fn4 :: (HasArgs "fn" args '["c", "b", "d"], WithoutArgs "fn" args '["a"]) => ArgsHMap "fn" args -> _
+fn4 :: (HasArgs "fn" t args '["c", "b", "d"], WithoutArgs "fn" t args '["a"]) => ArgsHMap "fn" t args -> _
 fn4 args = fn1 (#a := 3 .& args)
diff --git a/c-apis/MXNet/Base/Symbol.hs b/c-apis/MXNet/Base/Symbol.hs
--- a/c-apis/MXNet/Base/Symbol.hs
+++ b/c-apis/MXNet/Base/Symbol.hs
@@ -1,82 +1,100 @@
-{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE PartialTypeSignatures #-}
+{-# LANGUAGE ViewPatterns          #-}
 module MXNet.Base.Symbol where
 
-import Foreign.Marshal.Array
-import Foreign.Marshal.Alloc
-import Foreign.Storable
-import Foreign.Ptr
-import Foreign.C.String
-import Foreign.C.Types
-import Control.Monad
-import Control.Exception.Base (assert, Exception, throwIO)
-import Data.List (groupBy)
-import Data.Function
-import Data.Maybe
-import Text.Printf (printf)
-import Control.Concurrent.MVar
-import qualified Data.Vector as V
-import qualified Data.Vector.Mutable as VM
-import Data.Typeable (Typeable)
-import Control.Exception.Base (Exception, throwIO)
+import qualified Data.Vector.Mutable     as VM
+import           RIO
+import           RIO.List                (headMaybe, scanl, unzip)
+import qualified RIO.NonEmpty            as RNE
+import           RIO.Partial             (toEnum)
+import qualified RIO.Vector.Boxed        as V
+import qualified RIO.Vector.Boxed.Unsafe as V
 
-import qualified MXNet.Base.Raw as I
-import MXNet.Base.Types (ForeignData(..))
-import Debug.Trace
+import           Data.Typeable           (Typeable)
+import           Foreign.C.String
+import           Foreign.C.Types
+import           Foreign.Marshal.Alloc
+import           Foreign.Marshal.Array
+import           Foreign.Ptr
+import           Foreign.Storable
 
+import qualified MXNet.Base.Raw          as I
+import           MXNet.Base.Types        (ForeignData (..))
+
 newtype Symbol a = Symbol { unSymbol :: I.SymbolHandle }
 
 instance ForeignData (Symbol a) where
     touch = I.touchSymbolHandle . unSymbol
 
 data SymbolException = SymbolIndexOutOfBound Int Int
-                     | SymbolNameNotFound String
+    | SymbolNameNotFound Text
+    | SymbolMultipleOutputs Text
     deriving (Typeable, Show)
 instance Exception SymbolException
 
+data FShape = STensor
+    { _shape_nonempty :: NonEmpty Int
+    }
+    | SScalar
+    deriving Show
+
+shapeLength (STensor l) = length l
+shapeLength SScalar     = 0
+
+shapeToList (STensor l) = RNE.toList l
+shapeToList SScalar     = []
+
+shapeCons a (STensor s) = STensor $ a RNE.<| s
+shapeCons a SScalar     = STensor $ a RNE.:| []
+
 class SymbolClass s where
-    getName             :: s -> IO (Maybe String)
-    listArguments       :: s -> IO [String]
-    listOutputs         :: s -> IO [String]
-    listAuxiliaryStates :: s -> IO [String]
-    numOutputs          :: s -> IO Int
-    at                  :: s -> Int -> IO s
-    group               :: [s] -> IO s
-    internals           :: s -> IO s
-    inferShape          :: s -> [(String, [Int])] ->IO ([(String, [Int])], [(String, [Int])], [(String, [Int])], Bool)
+    getName             :: (HasCallStack, MonadIO m) => s -> m (Maybe Text)
+    listArguments       :: (HasCallStack, MonadIO m) => s -> m [Text]
+    listOutputs         :: (HasCallStack, MonadIO m) => s -> m [Text]
+    listAuxiliaryStates :: (HasCallStack, MonadIO m) => s -> m [Text]
+    numOutputs          :: (HasCallStack, MonadIO m) => s -> m Int
+    at                  :: (HasCallStack, MonadIO m) => s -> Int -> m s
+    group               :: (HasCallStack, MonadIO m) => [s] -> m s
+    internals           :: (HasCallStack, MonadIO m) => s -> m s
+    inferShape          :: (HasCallStack, MonadIO m)
+                        => s -> [(Text, FShape)]
+                        -> m ([(Text, FShape)], [(Text, FShape)], [(Text, FShape)], Bool)
 
-    at'                 :: s -> String -> IO s
+    at'                 :: (HasCallStack, MonadIO m) => s -> Text -> m s
     at' sym name = do
         all_names <- listOutputs sym
         case V.findIndex (== name) $ V.fromList all_names of
             Just idx -> at sym idx
-            Nothing -> throwIO (SymbolNameNotFound name)
+            Nothing  -> throwIO (SymbolNameNotFound name)
 
 instance SymbolClass I.SymbolHandle where
-    getName = I.mxSymbolGetName
-    listArguments       = I.mxSymbolListArguments
-    listOutputs         = I.mxSymbolListOutputs
-    listAuxiliaryStates = I.mxSymbolListAuxiliaryStates
-    numOutputs          = I.mxSymbolGetNumOutputs
-    at sym index = do
+    getName = liftIO . I.mxSymbolGetName
+    listArguments       = liftIO . I.mxSymbolListArguments
+    listOutputs         = liftIO . I.mxSymbolListOutputs
+    listAuxiliaryStates = liftIO . I.mxSymbolListAuxiliaryStates
+    numOutputs          = liftIO . I.mxSymbolGetNumOutputs
+    at sym index = liftIO $ do
         max <- numOutputs sym
         if index < 0 || index >= max then
             throwIO (SymbolIndexOutOfBound index max)
         else
             I.mxSymbolGetOutput sym index
-    group = I.mxSymbolCreateGroup
-    internals = I.mxSymbolGetInternals
+    group = liftIO . I.mxSymbolCreateGroup
+    internals = liftIO . I.mxSymbolGetInternals
 
-    inferShape sym known = do
+    inferShape sym known = liftIO $ do
         let (names, shapes) = unzip known
-            arg_ind = scanl (+) 0 $ map length shapes
-            arg_shp = concat shapes
+            arg_ind = scanl (+) 0 $ map shapeLength shapes
+            arg_shp = concatMap shapeToList shapes
         (inp_shp, out_shp, aux_shp, complete) <- I.mxSymbolInferShapePartial sym names arg_ind arg_shp
         inps <- listArguments sym
         outs <- listOutputs sym
         auxs <- listAuxiliaryStates sym
         return (pair inps inp_shp, pair outs out_shp, pair auxs aux_shp, complete)
       where
-        pair names shapes = filter (not . null . snd) $ zip names shapes
+        build name (RNE.nonEmpty -> Just s) = (name, STensor s)
+        build name _                        = (name, SScalar)
+        pair names shapes = zipWith build names shapes
 
 instance SymbolClass (Symbol a) where
     getName             = getName . unSymbol
@@ -86,31 +104,50 @@
     numOutputs          = numOutputs . unSymbol
     at (Symbol s)       = (Symbol <$>) . at s
     group = (Symbol <$>) . group . map unSymbol
-    internals           = (Symbol <$>) . internals . unSymbol 
+    internals           = (Symbol <$>) . internals . unSymbol
     inferShape          = inferShape  . unSymbol
 
+listInternals :: (SymbolClass sym, MonadIO m) => sym -> m [Text]
+listInternals sym = internals sym >>= listOutputs
 
-data StorageType = StorageTypeUndefined -- -1
-                 | StorageTypeDefault   --  0
-                 | StorageTypeRowSparse --  1
-                 | StorageTypeCSR       --  2
-  deriving (Eq, Bounded, Enum, Show)
+getInternalByName :: (SymbolClass sym, MonadIO m) => sym -> Text -> m (Maybe sym)
+getInternalByName sym name = liftIO $ handle on_exc $ do
+    layers <- internals sym
+    target <- at' layers name
+    return $ Just target
+  where
+      on_exc :: SymbolException -> IO (Maybe a)
+      on_exc _ = return Nothing
 
+inferOutputShape :: (SymbolClass sym, MonadIO m) => sym  -> [(Text, FShape)] -> m FShape
+inferOutputShape sym input_shapes = do
+    (_, out, _, _) <- inferShape sym input_shapes
+    case out of
+      [(_, shp)] -> return shp
+      _ -> throwIO (SymbolMultipleOutputs "use `inferShape` to get list of output shapes.")
+
+data StorageType = StorageTypeUndefined
+    | StorageTypeDefault
+    | StorageTypeRowSparse
+    | StorageTypeCSR
+    deriving (Eq, Bounded, Enum, Show)
+
 toStorageType :: Integral a => a -> StorageType
 toStorageType = toEnum . (+1) . fromIntegral
 
 fromStorageType :: Integral a => StorageType -> a
 fromStorageType = fromIntegral . (subtract 1) . fromEnum
 
-data MXDType = TyNone       -- -1
-             | TyFloat32    --  0
-             | TyFloat64    --  1
-             | TyFloat16    --  2
-             | TyUInt8      --  3
-             | TyInt32      --  4
-             | TyInt8       --  5
-             | TyInt64      --  6
-  deriving (Eq, Bounded, Enum, Show)
+-- MXDType values: -1, 0, 1, 2, 3, 4, 5, 6
+data MXDType = TyNone
+    | TyFloat32
+    | TyFloat64
+    | TyFloat16
+    | TyUInt8
+    | TyInt32
+    | TyInt8
+    | TyInt64
+    deriving (Eq, Bounded, Enum, Show)
 
 toMXDType :: Integral a => a -> MXDType
 toMXDType = toEnum . (+1) . fromIntegral
@@ -118,6 +155,7 @@
 fromMXDType :: Integral a => MXDType -> a
 fromMXDType = fromIntegral . (subtract 1) . fromEnum
 
+-- TODO: change String to Text
 class CustomOperation (Operation prop) => CustomOperationProp prop where
     -- list the names of inputs
     prop_list_arguments        :: prop -> [String]
@@ -128,7 +166,7 @@
     -- infer the shape.
     -- params: shapes of each inputs
     -- return: shapes of inputs, outputs, auxiliary states
-    prop_infer_shape :: prop -> [[Int]] -> ([[Int]], [[Int]], [[Int]])
+    prop_infer_shape :: prop -> [FShape] -> ([FShape], [FShape], [FShape])
     -- declare the dependency of symbols
     -- params: unique indices of inputs, outputs, auxiliary states
     -- return: dependant indices.
@@ -157,10 +195,10 @@
         in withAssert (ograd_stype', in_stype', out_stype', igrad_stype', aux_stype')
     prop_infer_type :: prop -> [MXDType] -> ([MXDType],[MXDType], [MXDType])
     prop_infer_type prop in_type =
-        let t0 = head in_type
-            out_type = replicate (length (prop_list_outputs prop)) t0
-            aux_type = replicate (length (prop_list_auxiliary_states prop)) t0
-        in (in_type, out_type, aux_type)
+        case headMaybe in_type of
+            Just t0 -> let out_type = replicate (length (prop_list_outputs prop)) t0
+                           aux_type = replicate (length (prop_list_auxiliary_states prop)) t0
+                       in (in_type, out_type, aux_type)
 
     data Operation prop :: *
     prop_create_operator :: prop -> [[Int]] -> [MXDType] -> IO (Operation prop)
@@ -180,20 +218,28 @@
              -> [I.NDArrayHandle]
              -> IO ()
 
-data ReqEnum = ReqNull | ReqWrite | ReqInplace | ReqAdd
+data ReqEnum = ReqNull
+    | ReqWrite
+    | ReqInplace
+    | ReqAdd
     deriving (Bounded, Enum)
 
-registerCustomOperator :: CustomOperationProp op => (String, [(String, String)] -> IO op) -> IO ()
+registerCustomOperator :: CustomOperationProp op => (Text, [(Text, Text)] -> IO op) -> IO ()
 registerCustomOperator (op_type, op_ctor) = do
     ptr_creator <- I.mkCustomOpPropCreator creator
     I.mxCustomOpRegister op_type ptr_creator
   where
     creator name argc keys values ret = do
         let argc' = fromIntegral argc
-        keys_ <- peekArray argc' keys   >>= mapM peekCString
-        vals_ <- peekArray argc' values >>= mapM peekCString
+        keys_ <- peekArray argc' keys   >>= mapM I.peekCStringT
+        vals_ <- peekArray argc' values >>= mapM I.peekCStringT
         prop <- op_ctor $ zip keys_ vals_
 
+        -- TODO: a safer way is use ForeignPtr,
+        -- malloc the str as ForeignPtr, and save
+        -- to the allocList. When the delete_entry is
+        -- called, it take away all ForeignPtr, and
+        -- effectively informs GC to revoke underlying memory.
         args <- mapM newCString (prop_list_arguments prop)
         ptr_args <- newArray $ args ++ [nullPtr]
 
@@ -264,19 +310,22 @@
         -- read each shape of each input
         inp_shape_0 <- zipWithM (\i j -> do ptr <- peekElemOff in_out_shapes_tensor i
                                             arr <- peekArray j ptr
-                                            return $ map fromIntegral arr)
+                                            case RNE.map fromIntegral <$> RNE.nonEmpty arr of
+                                                Nothing  -> return SScalar
+                                                Just shp -> return $ STensor shp)
                                 [0..] (map fromIntegral inp_dim_0)
 
         let (inp_shape, out_shape, aux_shape) = prop_infer_shape prop inp_shape_0
             all_shape = inp_shape ++ out_shape ++ aux_shape
-            all_shape_sizes = map length all_shape
+            all_shape_sizes = map shapeLength all_shape
 
         assert (length all_shape == num_tensor') (return ())
 
         pokeArray in_out_dim_tensor (map fromIntegral all_shape_sizes)
         -- no need to allocate new dimensions of inputs/outputs/auxiliaries
         -- only need to allocate new shapes for each
-        ptr_0 <- newArray (map fromIntegral (concat all_shape) :: [CInt])
+        let shape_vec = map fromIntegral $ concatMap shapeToList all_shape :: [CInt]
+        ptr_0 <- newArray shape_vec
         modifyMVar_ allocList (return . (castPtr ptr_0 :))
 
         let size_UINT = sizeOf (undefined :: I.MX_UINT)
@@ -337,8 +386,11 @@
             num_tensor' = fromIntegral num_tensor
         tags' <- peekArray num_tensor' tags
         tensor_types' <- peekArray num_tensor' tensor_stypes
-        let tensors = groupBy ((==) `on` fst) (zip tags' tensor_types')
-            tensors_table = map (\t -> (fst (head t), map (toStorageType . snd) t)) tensors
+        let tensors = RNE.groupBy ((==) `on` fst) (zip tags' tensor_types')
+            tensors_table = map (\t ->
+                let tag = fst $ RNE.head t
+                    sto = RNE.toList $ RNE.map (toStorageType . snd) t
+                in (tag, sto)) tensors
             [ograd0, input0, output0, igrad0, aux0] = map (fromMaybe [] . flip lookup tensors_table) [3, 0, 1, 2, 4]
             (ograd, input, output, igrad, aux) = prop_infer_storage_type_backward prop ograd0 input0 output0 igrad0 aux0
             all_stypes = map fromStorageType $ ograd ++ input ++ output ++ igrad ++ aux
@@ -358,7 +410,7 @@
         let size = 3
         ptr_callbacks <- mallocArray size
         ptr_contexts  <- newArray (replicate size nullPtr)
-        allocList <- newMVar $ [castPtr ptr_callbacks, castPtr ptr_contexts]
+        allocList <- newMVar $ ([castPtr ptr_callbacks, castPtr ptr_contexts] :: [_])
 
         ptr_delete_entry        <- I.mkCustomFunctionDelFunc (delete_entry allocList)
         ptr_func_forward_entry  <- I.mkCustomFunctionBwdFunc (func_forward_entry  op)
@@ -415,4 +467,5 @@
         backward op reqs in_data out_data in_grad out_grad aux
         return 1
 
-    (!) = (V.!)
+    (!) = V.unsafeIndex
+
diff --git a/c-apis/MXNet/Base/Tensor.hs b/c-apis/MXNet/Base/Tensor.hs
new file mode 100644
--- /dev/null
+++ b/c-apis/MXNet/Base/Tensor.hs
@@ -0,0 +1,78 @@
+{-# LANGUAGE MultiParamTypeClasses  #-}
+{-# LANGUAGE TypeFamilyDependencies #-}
+module MXNet.Base.Tensor where
+
+import           Data.Bifunctor           (bimap)
+import           Data.Kind                (Constraint)
+import           RIO
+import           RIO.List                 (unzip)
+
+import {-# SOURCE #-} MXNet.Base.NDArray
+import           MXNet.Base.Raw.Common
+import           MXNet.Base.Raw.NDArray
+import           MXNet.Base.Raw.Symbol
+import           MXNet.Base.Spec.Operator (ArgsHMap)
+import           MXNet.Base.Symbol
+import           MXNet.Base.Types
+
+
+-- TensorApply is injective
+type family TensorApply t = c | c -> t where
+    TensorApply NDArrayHandle = Maybe [NDArrayHandle] -> IO [NDArrayHandle]
+    TensorApply (NDArray a) = Maybe [NDArray a] -> IO [NDArray a]
+    TensorApply SymbolHandle = Text -> IO SymbolHandle
+
+type family TensorMonad t :: * -> *
+
+type instance TensorMonad (NDArray a)   = IO
+type instance TensorMonad NDArrayHandle = IO
+
+type TensorM t = TensorMonad t t
+
+
+class TensorOp ti to where
+    apply :: HasCallStack => Text -> [(Text, Text)] -> Either [(Text, ti)] [ti] -> TensorApply to
+
+
+class TensorOp ti to => PrimTensorOp ti to where
+    prim :: HasCallStack => (ArgsHMap s ti a -> TensorApply to) -> ArgsHMap s ti a -> TensorM to
+
+
+instance TensorOp NDArrayHandle NDArrayHandle where
+    apply opname scalars tensors outputs = do
+        let tensors' = case tensors of
+                         Left kwargs -> snd $ unzip kwargs
+                         Right args  -> args
+        op <- nnGetOpHandle opname
+        mxImperativeInvoke (fromOpHandle op) tensors' scalars outputs
+
+
+instance (DType a, DType b) => TensorOp (NDArray a) (NDArray b) where
+    apply opname scalars tensors outputs = do
+        let tensors' = bimap (map (second unNDArray)) (map unNDArray) tensors
+            outputs' = fmap (map unNDArray) outputs :: Maybe [NDArrayHandle]
+        ret <- apply opname scalars tensors' outputs' :: IO [NDArrayHandle]
+        return $ map NDArray ret
+
+
+instance TensorOp SymbolHandle SymbolHandle where
+    apply opname scalars tensors name = do
+        let (scalarkeys, scalarvals) = unzip scalars
+            (tensorkeys, tensorvals) = case tensors of
+                                         Left kwargs -> first Just $ unzip kwargs
+                                         Right args  -> (Nothing, args)
+        op <- nnGetOpHandle opname
+        sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op)
+                                          scalarkeys
+                                          scalarvals
+        mxSymbolCompose sym name tensorkeys tensorvals
+        return sym
+
+instance PrimTensorOp NDArrayHandle NDArrayHandle where
+    prim op args = op args Nothing >>= \[x] -> return x
+
+
+instance (DType a, DType b) => PrimTensorOp (NDArray a) (NDArray b) where
+    prim op args = op args Nothing >>= \[x] -> return x
+
+
diff --git a/c-apis/MXNet/Base/Types.hs b/c-apis/MXNet/Base/Types.hs
--- a/c-apis/MXNet/Base/Types.hs
+++ b/c-apis/MXNet/Base/Types.hs
@@ -1,29 +1,48 @@
-{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE DataKinds    #-}
 {-# LANGUAGE TypeFamilies #-}
 module MXNet.Base.Types where
 
-import Foreign.Storable (Storable)
-import Data.Vector.Unboxed (Unbox)
-import Data.Proxy (Proxy(..))
-import GHC.TypeLits (Symbol, KnownSymbol)
+import           Data.Proxy         (Proxy (..))
+import           GHC.TypeLits       (KnownSymbol, Symbol)
+import           RIO
+import           RIO.Vector.Unboxed (Unbox)
 
-data Context = Context { _device_type :: Int, _device_id :: Int }
-  deriving (Eq, Show)
+data Context = Context
+    { _device_type :: Int
+    , _device_id   :: Int
+    }
+    deriving (Eq, Show)
 
-class (Storable a, Unbox a, Show a, Num a, Floating a, Real a, RealFrac a, KnownSymbol (DTypeName a)) => DType a where
-  type DTypeName a :: Symbol
-  typename :: a -> Proxy (DTypeName a)
-  typename a = Proxy
+class (Storable a,
+       Unbox a,
+       Show a,
+       Eq a,
+       Num a,
+       Read a,
+       KnownSymbol (DTypeName a)) => DType a where
+    type DTypeName a :: Symbol
+    typename :: a -> Proxy (DTypeName a)
+    typename a = Proxy
 
-  flag :: a -> Int
+    flag :: a -> Int
 
+
+class (RealFloat a, DType a) => FloatDType a
+
 instance DType Float where
-  type DTypeName Float = "float32"
-  flag _ = 0    -- mshadow::kFloat32
+    type DTypeName Float = "float32"
+    flag _ = 0    -- mshadow::kFloat32
 
 instance DType Double where
-  type DTypeName Double = "float64"
-  flag _ = 1    -- mshadow::kFloat64
+    type DTypeName Double = "float64"
+    flag _ = 1    -- mshadow::kFloat64
+
+instance FloatDType Float
+instance FloatDType Double
+
+instance DType Word8 where
+    type DTypeName Word8 = "uint8"
+    flag _ = 3    -- mshadow::kUint8
 
 contextCPU :: Context
 contextCPU = Context 1 0
diff --git a/cmdline/Main.hs b/cmdline/Main.hs
--- a/cmdline/Main.hs
+++ b/cmdline/Main.hs
@@ -1,29 +1,35 @@
 module Main where
 
-import Options.Applicative hiding (optional)
-import Data.Semigroup ((<>))
-import Language.Haskell.Exts
-import qualified Data.Text as T
-import System.Log.Logger
-import Control.Monad
-import Control.Monad.Writer (Writer, execWriter, tell)
-import Data.Either
-import Data.Char (toLower, isUpper, isSpace, isAlphaNum)
-import Text.Printf (printf)
-import Text.ParserCombinators.ReadP
-import System.FilePath
-import System.Directory
+import           Prelude
+import           RIO                          (first, forM, on, zipWithM_, (<>))
+import           RIO.Char                     (isAlphaNum, isSpace, isUpper,
+                                               toLower)
+import           RIO.Directory
+import           RIO.FilePath                 (FilePath, (</>))
+import           RIO.List                     (sortBy)
+import qualified RIO.Text                     as T
+import           RIO.Writer                   (Writer, execWriter, tell)
 
-import MXNet.Base.Raw
+import           Data.Tuple.Ops               (uncons)
+import           Language.Haskell.Exts
+import           Options.Applicative          hiding (optional)
+import           System.Log.Logger
+import           Text.ParserCombinators.ReadP
+import           Text.Printf                  (printf)
 
+import           MXNet.Base.Raw.Common
+import           MXNet.Base.Raw.DataIter
+import           MXNet.Base.Raw.NDArray
+import           MXNet.Base.Raw.Symbol
+
 _module_ = "Main"
 
-data Arguments = Arguments {
-    output_dir :: FilePath
-}
+data Arguments = Arguments
+    { output_dir :: FilePath
+    }
 
 args_spec = Arguments
-         <$> strOption (long "output" <> short 'o' <> value "operators" <> metavar "OUTPUT-DIR")
+         <$> strOption (long "output" <> short 'o' <> value "tmp" <> metavar "OUTPUT-DIR")
 
 main = do
     updateGlobalLogger _module_ (setLevel INFO)
@@ -32,294 +38,246 @@
     createDirectoryIfMissing True base
 
     ops  <- mxSymbolListAtomicSymbolCreators
+    op_names <- mapM getOpName ops
+    let ops_sorted = map snd $ sortBy (compare `on` fst) $ zip op_names ops
 
-    infoM _module_ "Generating Symbol operators..."
-    symbols <- concat <$> mapM genSymOp ops
-    writeFile (base </> "Symbol.hs") $ prettyPrint (modSymbol symbols)
+    infoM _module_ "Generating NDArray/Symbol operators..."
+    ops <- concat <$> mapM genTensorOp ops_sorted
+    writeFile (base </> "Tensor.hs") $ prettyPrint (modTensor ops)
 
-    infoM _module_ "Generating NDArray operators..."
-    arrays  <- concat <$> mapM genArrOp ops
-    writeFile (base </> "NDArray.hs") $ prettyPrint (modArray arrays)
+    dataitercreators  <- mxListDataIters
+    infoM _module_ "Generating DataIter..."
+    dataiters <- concat <$> mapM genDataIter (zip dataitercreators [0..])
+    let base = output_dir args </> "MXNet" </> "Base"
+    writeFile (base </> "DataIter.hs") $ prettyPrint (modDataIter dataiters)
 
   where
     opts = info (args_spec <**> helper) (fullDesc <> progDesc "Generate MXNet operators")
-    modSymbol = Module () (Just $ ModuleHead () (ModuleName () "MXNet.Base.Operators.Symbol") Nothing Nothing) []
-                [ simpleImport "MXNet.Base.Raw"
-                , simpleImport "MXNet.Base.Spec.Operator"
-                , simpleImport "MXNet.Base.Spec.HMap"
-                , simpleImportVars "Data.Maybe" ["catMaybes", "fromMaybe"]]
-    modArray  = Module () (Just $ ModuleHead () (ModuleName () "MXNet.Base.Operators.NDArray") Nothing Nothing) []
-                [ simpleImport "MXNet.Base.Raw"
+    modTensor = Module () (Just $ ModuleHead () (ModuleName () "MXNet.Base.Operators.Tensor") Nothing Nothing) []
+                [ simpleImport "RIO"
+                , simpleImport "RIO.List"
+                , simpleImport "MXNet.Base.Raw"
                 , simpleImport "MXNet.Base.Spec.Operator"
                 , simpleImport "MXNet.Base.Spec.HMap"
+                , simpleImport "MXNet.Base.Tensor"
                 , simpleImportVars "Data.Maybe" ["catMaybes", "fromMaybe"]]
+    modDataIter = Module () (Just $ ModuleHead () (ModuleName () "MXNet.Base.DataIter") Nothing Nothing) []
+                  [ simpleImport "RIO"
+                  , simpleImport "RIO.List"
+                  , simpleImportVars "RIO.List.Partial" ["(!!)"]
+                  , simpleImport "MXNet.Base.Raw"
+                  , simpleImport "MXNet.Base.Spec.Operator"
+                  , simpleImport "MXNet.Base.Spec.HMap"
+                  , simpleImportVars "Data.Maybe" ["catMaybes", "fromMaybe"]]
 
+getOpName :: AtomicSymbolCreator -> IO String
+getOpName = fmap T.unpack . mxSymbolGetAtomicSymbolName
+
+tensorVar = tyVarIdent "t"
+tensorVar2 = tyVarIdent "o"
+
 makeParamInst :: String -> [ResolvedType] -> Bool -> Decl ()
 makeParamInst symname typs symbolapi =
-    TypeInsDecl () (tyApp (tyCon $ unQual $ name "ParameterList") (tyPromotedStr symname_with_appendix))
+    TypeInsDecl () (tyApp (tyApp (tyCon $ unQual $ name "ParameterList") (tyPromotedStr symname)) tensorVar)
                    (tyPromotedList paramList)
   where
-    symname_with_appendix = symname ++ (if symbolapi then "(symbol)" else "(ndarray)")
     paramList = map (\(name, typ1, typ2) -> tyPromotedTuple [tyPromotedStr name, tyApp typ1 typ2]) typs
 
-data GenFlag = GenSymbolOp | GenNDArrayReturn | GenNDArrayUpdate
+data GenFlag = GenSymbolOp
+    | GenNDArrayReturn
+    | GenNDArrayUpdate
 
-makeSignature :: String -> GenFlag -> [Asst ()]-> Decl ()
-makeSignature symname flag extra_constraints =
-    let (funname, appendix, rettype, maketype) =
-            case flag of
-              GenSymbolOp      -> (symname, "(symbol)", tyCon $ unQual $ name "SymbolHandle", tyFun (tyCon $ unQual $ name "String"))
-              GenNDArrayReturn -> (symname, "(ndarray)", tyList $ tyCon $ unQual $ name "NDArrayHandle", id)
-              GenNDArrayUpdate -> (symname ++ "_upd", "(ndarray)", unit_tycon (), tyFun (tyList $ tyCon $ unQual $ name "NDArrayHandle"))
-        symname_with_appendix = symname ++ appendix
-        cxfullfill = appA (name "Fullfilled") [tyPromotedStr symname_with_appendix, tyVarIdent "args"]
-        cx_all = if null extra_constraints then cxSingle cxfullfill else cxTuple (cxfullfill : extra_constraints)
-        fun = tyFun (tyApp (tyApp (tyCon $ unQual $ name "ArgsHMap") (tyPromotedStr symname_with_appendix)) (tyVarIdent "args"))
-                    (tyApp (tyCon $ unQual $ name "IO") rettype)
-    in tySig [name funname] $ tyForall [unkindedVar (name "args")] cx_all $ (maketype fun)
+makeSignature :: String -> Type () -> Type () -> [Asst ()] -> Decl ()
+makeSignature symname ti to extra_constraints =
+    let cxfullfill = appA (name "Fullfilled") [tyPromotedStr symname, ti, tyVarIdent "a"]
+        cxtensor   = appA (name "TensorOp") [ti, to]
+        callstack  = appA (name "HasCallStack") []
+        cx_all = cxTuple (cxtensor : cxfullfill : callstack : extra_constraints)
+        fun = tyFun (let hmap = tyCon $ unQual $ name "ArgsHMap"
+                     in hmap `tyApp` tyPromotedStr symname
+                             `tyApp` ti
+                             `tyApp` tyVarIdent "a")
+                    ((tyCon $ unQual $ name "TensorApply") `tyApp ` to)
+        vars = map (unkindedVar . name) $ "a" : "t" : if ti == to then [] else ["o"]
+    in tySig [name symname] $ tyForall vars cx_all fun
 
-genSymOp :: AtomicSymbolCreator -> IO [Decl ()]
-genSymOp sc = do
-    (symname, desc, argname, argtype, argdesc, key_var_num_args, rettyp) <- mxSymbolGetAtomicSymbolInfo sc
+genTensorOp :: AtomicSymbolCreator -> IO [Decl ()]
+genTensorOp sc = do
+    (symname_t, _, argname_t, argtype_t, _, key_var_num_args_t, rettyp) <- mxSymbolGetAtomicSymbolInfo sc
+    let symname = T.unpack symname_t
+        argname = map T.unpack argname_t
+        argtype = map T.unpack argtype_t
+        key_var_num_args = T.unpack key_var_num_args_t
+
     if symname `elem` ["_Native", "_NDArray"] then
         return []
     else do
         let symname_ = normalizeName symname
-            (errs, scalarTypes, tensorTypes, arrayTypes) = execWriter $ zipWithM_ (resolveHaskellType True) argname argtype
+            out_new = symname `elem` ["Cast"]
+            out_var = if out_new then tensorVar2 else tensorVar
+            (errs, scalarTypes, tensorKeyTypes, tensorVarTypes) = execWriter $ zipWithM_ (resolveHaskellType ResolveTensor) argname argtype
 
         if not (null errs) then do
             forM errs $ \(name, msg) ->
                 errorM _module_ (printf "Function: %s %s" symname msg)
             return []
-        else if (length arrayTypes >= 2) then do
-            errorM _module_ (printf "Function: %s has more than one Symbol[] argument." symname)
+        else if (length tensorVarTypes >= 2) then do
+            errorM _module_ (printf "Function: %s has more than one NDArray/Symbol[] argument." symname)
             return []
-        else if (not (null tensorTypes) && not (null arrayTypes)) then do
-            errorM _module_ (printf "Function: %s is varadic, but it also has Symbol argument." symname)
+        else if (not (null tensorKeyTypes) && not (null tensorVarTypes)) then do
+            errorM _module_ (printf "Function: %s has both NDArray/Symbol and NDArray/Symbol[] arguments." symname)
             return []
         else do
-            let paramListInst = makeParamInst symname_ (scalarTypes ++ tensorTypes ++ arrayTypes) True
-                sig = makeSignature symname_ GenSymbolOp $ 
+            let paramListInst = makeParamInst symname_ (scalarTypes ++ tensorKeyTypes ++ tensorVarTypes) True
+                sig = makeSignature symname_ tensorVar out_var $
                         -- the "Custom" is a little special, because it allow extra arguments
-                        if symname == "Custom" 
+                        if symname == "Custom"
                             --    PopKey (ArgOf "_Custom(symbol)") args "data",
                             --    Dump (PopResult (ArgOf "_Custom(symbol)") args "data"))
-                            then let argOfCustom = tyParen $ tyApp (tyCon $ unQual $ name "ArgOf") (tyPromotedStr "_Custom(symbol)")
-                                 in [appA (name "PopKey") [argOfCustom, tyVarIdent "args", tyPromotedStr "data"],
+                            then let argOfCustom = tyParen $ (tyCon $ unQual $ name "ArgOf") `tyApp`
+                                                             (tyPromotedStr "_Custom") `tyApp`
+                                                             tensorVar
+                                 in [appA (name "PopKey") [argOfCustom, tyVarIdent "a", tyPromotedStr "data"],
                                      appA (name "Dump") [ tyParen $
-                                        (tyCon $ unQual $ name "PopResult") `tyApp` 
-                                        argOfCustom `tyApp` 
-                                        tyVarIdent "args" `tyApp` 
+                                        (tyCon $ unQual $ name "PopResult") `tyApp`
+                                        argOfCustom `tyApp`
+                                        tyVarIdent "a" `tyApp`
                                         tyPromotedStr "data"]]
                             else []
-            let fun = sfun (name symname_) [name "name", name "args"] (UnGuardedRhs () body) Nothing
-                make_scalar_values = 
-                    if symname == "Custom" 
+            let fun = sfun (name symname_) [name "args"] (UnGuardedRhs () body) Nothing
+                make_scalar_values =
+                    if symname == "Custom"
                         -- dump (pop args #data)
                         then function "dump" `app` (
-                                function "pop" `app` (var $ name "args") `app` (OverloadedLabel () "data"))
+                                function "pop" `app`
+                                (var $ name "args") `app`
+                                OverloadedLabel () "data")
                         -- catMaybes
                         --    [("KEY",) . showValue <$> (args !? #KEY :: Maybe VALUE_TYPE),
                         --     ... ]
-                        else function "catMaybes" `app` listE 
-                                [ infixApp (infixApp (tupleSection [Just $ strE argkey, Nothing]) 
-                                                     (op $ sym ".") 
+                        else function "catMaybes" `app` listE
+                                ([ infixApp (infixApp (tupleSection [Just $ strE argkey, Nothing])
+                                                     (op $ sym ".")
                                                      (function "showValue"))
                                            (op $ sym "<$>") $
-                                           ExpTypeSig () (infixApp (var $ name "args") 
-                                                                   (op $ sym "!?") 
-                                                                   (OverloadedLabel () argkey)) 
-                                                      (tyApp (tyCon $ unQual $ name "Maybe") typ) 
-                                | (argkey, _, typ) <- scalarTypes]
+                                               ExpTypeSig () (infixApp (var $ name "args")
+                                                                   (op $ sym "!?")
+                                                                   (OverloadedLabel () argkey))
+                                                      (tyApp (tyCon $ unQual $ name "Maybe") typ)
+                                 | (argkey, _, typ) <- scalarTypes] ++
+                                 if null key_var_num_args || null tensorVarTypes || key_var_num_args `elem` [k | (k,_,_) <- scalarTypes]
+                                 then []
+                                 else [(con $ unQual $ name "Just") `app` tuple [
+                                    strE key_var_num_args,
+                                    function "showValue" `app` (function "length" `app` (var $ name "tensorVarArgs"))]])
                 body =  letE ([
                           patBind (pvar $ name "scalarArgs") make_scalar_values
-                        , patBind (pTuple [pvar $ name "scalarkeys", pvar $ name "scalarvals"]) (app (function "unzip") $ var $ name "scalarArgs")
-                        , patBind (pvar $ name "tensorArgs") (function "catMaybes"
+                        , patBind (pvar $ name "tensorKeyArgs") (function "catMaybes"
                             `app` listE [
                                 infixApp (tupleSection [Just $ strE argkey, Nothing]) (op $ sym "<$>") $
-                                ExpTypeSig () (infixApp (var $ name "args") (op $ sym "!?") (OverloadedLabel () argkey)) (tyApp (tyCon $ unQual $ name "Maybe") typ) | (argkey, _, typ) <- tensorTypes])
-                        , patBind (pTuple [pvar $ name "tensorkeys", pvar $ name "tensorvals"]) (app (function "unzip") $ var $ name "tensorArgs")]
-                        ++
-                        case arrayTypes of
-                          [(argkey,_,_)] -> [patBind (pvar $ name "array") $ function "fromMaybe"
-                                                `app` eList
-                                                `app` ExpTypeSig ()
-                                                        (infixApp (var $ name "args") (op $ sym "!?") (OverloadedLabel () argkey))
-                                                        (tyApp (tyCon $ unQual $ name "Maybe") (tyList $ tyCon $ unQual $ name "SymbolHandle"))]
+                                ExpTypeSig ()
+                                    (infixApp (var $ name "args") (op $ sym "!?") (OverloadedLabel () argkey))
+                                    (tyApp (tyCon $ unQual $ name "Maybe") typ) | (argkey, _, typ) <- tensorKeyTypes])
+                        ] ++
+                        case tensorVarTypes of
+                          [(argkey,_,_)] ->
+                              [patBind (pvar $ name "tensorVarArgs") $ function "fromMaybe"
+                                `app` eList
+                                `app` ExpTypeSig ()
+                                    (infixApp (var $ name "args") (op $ sym "!?") (OverloadedLabel () argkey))
+                                    (tyApp (tyCon $ unQual $ name "Maybe") (tyList tensorVar))]
                           _ -> [])
-                        (doE $
-                            [ genStmt (pvar $ name "op") $ function "nnGetOpHandle"`app` strE symname ] ++
-                            ( if null arrayTypes then
-                                  [ genStmt (pvar $ name "sym") $ function "mxSymbolCreateAtomicSymbol"
-                                      `app` (function "fromOpHandle" `app` (var $ name "op"))
-                                      `app` (var $ name "scalarkeys")
-                                      `app` (var $ name "scalarvals")
-                                  , qualStmt $ function "mxSymbolCompose"
-                                      `app` (var $ name "sym")
-                                      `app` (var $ name "name")
-                                      `app` ((con $ unQual $ name "Just") `app` (var $ name "tensorkeys"))
-                                      `app` (var $ name "tensorvals") ]
-                              else if null key_var_num_args then
-                                  -- the size of array are determined pragmatically (e.g. Custom)
-                                  [ genStmt (pvar $ name "sym") $ function "mxSymbolCreateAtomicSymbol"
-                                      `app` (function "fromOpHandle" `app` (var $ name "op"))
-                                      `app` (var $ name "scalarkeys")
-                                      `app` (var $ name "scalarvals")
-                                  , qualStmt $ function "mxSymbolCompose"
-                                      `app` (var $ name "sym")
-                                      `app` (var $ name "name")
-                                      `app` (con $ unQual $ name "Nothing")
-                                      `app` (var $ name "array") ]
-                              else
-                                  -- the size of array should be provided in the arg named `key_var_num_args`
-                                  -- but it is sometimes optional when calling the symbol. If it is not given
-                                  -- explicitly, calculate its length.
-                                  [ genStmt (pvar $ name "sym") $
-                                      If () (function "hasKey" `app` (var $ name "args") `app` (OverloadedLabel () key_var_num_args))
-                                          (function "mxSymbolCreateAtomicSymbol"
-                                              `app` (function "fromOpHandle" `app` (var $ name "op"))
-                                              `app` (var $ name "scalarkeys")
-                                              `app` (var $ name "scalarvals"))
-                                          (function "mxSymbolCreateAtomicSymbol"
-                                              `app` (function "fromOpHandle" `app` (var $ name "op"))
-                                              `app` (infixApp (strE key_var_num_args) (QConOp () $ Special () $ Cons ()) (var $ name "scalarkeys"))
-                                              `app` (infixApp (function "showValue" `app` (function "length" `app` (var $ name "array")))  (QConOp () $ Special () $ Cons ()) (var $ name "scalarvals")))
-                                  , qualStmt $ function "mxSymbolCompose"
-                                      `app` (var $ name "sym")
-                                      `app` (var $ name "name")
-                                      `app` (con $ unQual $ name "Nothing")
-                                      `app` (var $ name "array")] ) ++
-                            [ qualStmt $ function "return" `app` (var $ name "sym") ])
+                        (function "apply"
+                            `app` (strE symname)
+                            `app` (var $ name "scalarArgs")
+                            `app` (if null tensorVarTypes
+                                      then function "Left" `app` (expTypeSig
+                                            (var $ name "tensorKeyArgs")
+                                            (tyList $ tyTuple [tyCon $ unQual $ name "Text", tensorVar]))
+                                      else function "Right" `app` (var $ name "tensorVarArgs")))
             return [paramListInst, sig, fun]
 
-genArrOp :: AtomicSymbolCreator -> IO [Decl ()]
-genArrOp sc = do
-    (symname, desc, argname0, argtype0, argdesc, key_var_num_args, rettyp) <- mxSymbolGetAtomicSymbolInfo sc
+genDataIter :: (DataIterCreator, Integer) -> IO [Decl ()]
+genDataIter (dataitercreator, index) = do
+    (diname_t, _, argnames_t, argtypes_t, _) <- mxDataIterGetIterInfo dataitercreator
+    let diname = normalizeName $ T.unpack diname_t
+        argnames = map T.unpack argnames_t
+        argtypes = map T.unpack argtypes_t
 
-    -- some ops (names like *_mkl_*) are malformed. They declare zero args, but actually has the "data" and "num_args"
-    let (argname, argtype) = if not (null key_var_num_args) && null argname0 then
-                                (["data","num_args"], ["NDArray-or-Symbol[]","int, required"])
-                             else
-                                (argname0, argtype0)
+        (errs, scalarTypes, _, _) = execWriter $ zipWithM_ (resolveHaskellType ResolveDataIter) argnames argtypes
 
-    if symname `elem` ["_Native", "_NDArray", "Custom"] then
-        return []
-    else do
-        let symname_ = normalizeName symname
-            (errs, scalarTypes, tensorTypes, arrayTypes) = execWriter $ zipWithM_ (resolveHaskellType False) argname argtype
+        -- parameter list
+        paramList = map (\(name, typ1, typ2) -> tyPromotedTuple [tyPromotedStr name, tyApp typ1 typ2]) scalarTypes
+        paramInst = TypeInsDecl ()
+                        (tyApp (tyApp (tyCon $ unQual $ name "ParameterList") (tyPromotedStr diname)) (tyVarIdent "dummy"))
+                        (tyPromotedList paramList)
 
-        if not (null errs) then do
-            forM errs $ \(name, msg) ->
-                errorM _module_ (printf "Function: %s %s" symname msg)
-            return []
-        else if (length arrayTypes >= 2) then do
-            errorM _module_ (printf "Function: %s has more than Symbol[] argument." symname)
-            return []
-        else if (not (null tensorTypes) && not (null arrayTypes)) then do
-            errorM _module_ (printf "Function: %s is varadic, but it also has Symbol argument." symname)
-            return []
-        else do
-            let paramListInst = makeParamInst symname_ (scalarTypes ++ tensorTypes ++ arrayTypes) False
-                sig1 = makeSignature symname_ GenNDArrayReturn []
-                sig2 = makeSignature symname_ GenNDArrayUpdate []
-            let fun1 = sfun (name symname_) [name "args"]
-                        (UnGuardedRhs () (body (lastArgOfInvoke GenNDArrayReturn) True)) Nothing
-                fun2 = sfun (name $ symname_ ++ "_upd") [name "outputs", name "args"]
-                        (UnGuardedRhs () (body (lastArgOfInvoke GenNDArrayUpdate) False)) Nothing
-                lastArgOfInvoke GenNDArrayReturn = con $ unQual $ name "Nothing"
-                lastArgOfInvoke GenNDArrayUpdate = (con $ unQual $ name "Just") `app` (var $ name "outputs")
-                body lastarg retval =
-                    letE ([
-                          patBind (pvar $ name "scalarArgs") (function "catMaybes"
-                            `app` listE [
-                                infixApp (infixApp (tupleSection [Just $ strE argkey, Nothing]) (op $ sym ".") (function "showValue")) (op $ sym "<$>") $
-                                ExpTypeSig () (infixApp (var $ name "args") (op $ sym "!?") (OverloadedLabel () argkey)) (tyApp (tyCon $ unQual $ name "Maybe") typ) | (argkey, _, typ) <- scalarTypes])
-                        -- , patBind (pTuple [pvar $ name "scalarkeys", pvar $ name "scalarvals"]) (app (function "unzip") $ var $ name "scalarArgs")
-                        , patBind (pvar $ name "tensorArgs") (function "catMaybes"
-                            `app` listE [
-                                infixApp (tupleSection [Just $ strE argkey, Nothing]) (op $ sym "<$>") $
-                                ExpTypeSig () (infixApp (var $ name "args") (op $ sym "!?") (OverloadedLabel () argkey)) (tyApp (tyCon $ unQual $ name "Maybe") typ) | (argkey, _, typ) <- tensorTypes])
-                        , patBind (pTuple [pvar $ name "tensorkeys", pvar $ name "tensorvals"]) (app (function "unzip") $ var $ name "tensorArgs")]
-                        ++
-                        case arrayTypes of
-                          [(argkey,_,_)] -> [patBind (pvar $ name "array") $ function "fromMaybe"
-                                                `app` eList
-                                                `app` ExpTypeSig ()
-                                                        (infixApp (var $ name "args") (op $ sym "!?") (OverloadedLabel () argkey))
-                                                        (tyApp (tyCon $ unQual $ name "Maybe") (tyList $ tyCon $ unQual $ name "NDArrayHandle"))]
-                          _ -> [])
-                        (doE $
-                            [ genStmt (pvar $ name "op") $ function "nnGetOpHandle"`app` strE symname ] ++
-                            ( if null key_var_num_args then
-                                  [ genStmt (pvar $ name "listndarr") $ function "mxImperativeInvoke"
-                                      `app` (function "fromOpHandle" `app` (var $ name "op"))
-                                      `app` (var $ name "tensorvals")
-                                      `app` (var $ name $ "scalarArgs")
-                                      `app` lastarg
-                                  ]
-                              else
-                                  [ letStmt [
-                                        patBind (pvar $ name "scalarArgs'") (
-                                            If () (function "hasKey" `app` (var $ name "args") `app` (OverloadedLabel () key_var_num_args))
-                                                (var $ name $ "scalarArgs")
-                                                (let key_var = Con () (Special () (TupleCon () Boxed 2))
-                                                                `app` (strE key_var_num_args)
-                                                                `app` (function "showValue" `app` (function "length" `app` (var $ name "array")))
-                                                in infixApp key_var (QConOp () $ Special () $ Cons ()) (var $ name $ "scalarArgs"))
-                                        )]
-                                  , genStmt (pvar $ name "listndarr") $ function "mxImperativeInvoke"
-                                                  `app` (function "fromOpHandle" `app` (var $ name "op"))
-                                                  `app` (var $ name "array")
-                                                  `app` (var $ name $ "scalarArgs'")
-                                                  `app` lastarg
-                                  ]) ++
-                            [ qualStmt $ function "return" `app` (if retval then var $ name "listndarr" else unit_con ()) ])
-            return [paramListInst, sig1, fun1, sig2, fun2]
+        -- signature
+        void = tyTuple []
+        cxfullfill = appA (name "Fullfilled") [tyPromotedStr diname, void, tyVarIdent "a"]
+        tyfun = tyFun
+                    (let hmap = tyCon $ unQual $ name "ArgsHMap"
+                     in hmap `tyApp` tyPromotedStr diname `tyApp` void `tyApp` tyVarIdent "a")
+                    (tyApp (tyCon $ unQual $ name "IO") (tyCon $ unQual $ name "DataIterHandle"))
+        tysig = tySig [name diname] $ tyForall [unkindedVar (name "a")] (cxSingle cxfullfill) tyfun
 
+        -- function
+        fun = sfun (name diname) [name "args"] (UnGuardedRhs () body) Nothing
+        body = letE ([
+                patBind (pvar $ name "allargs") (function "catMaybes"
+                    `app` listE [
+                        infixApp (infixApp (tupleSection [Just $ strE argkey, Nothing]) (op $ sym ".") (function "showValue")) (op $ sym "<$>") $
+                            ExpTypeSig () (infixApp (var $ name "args") (op $ sym "!?") (OverloadedLabel () argkey)) (tyApp (tyCon $ unQual $ name "Maybe") typ) | (argkey, _, typ) <- scalarTypes])
+              , patBind (pTuple [pvar $ name "keys", pvar $ name "vals"]) (app (function "unzip") $ var $ name "allargs")
+              ]) (doE $ [
+                  genStmt (pvar $ name "dis") $ function "mxListDataIters",
+                  genStmt (pvar $ name "di") $ function "return" `app` (infixApp (var $ name "dis") (op $ sym "!!") (intE index)),
+                  qualStmt $ function "mxDataIterCreateIter" `app` (var $ name "di") `app` (var $ name "keys") `app` (var $ name "vals")
+              ])
+
+    if not (null errs) then do
+       forM errs $ \(name, msg) ->
+           errorM _module_ (printf "Function: %s %s" diname msg)
+       return []
+    else
+       return [paramInst, tysig, fun]
+
 normalizeName :: String -> String
-normalizeName name@(c:cs)
-    | isUpper c = '_' : name
-    | name == "where" = "_where"
-    | otherwise = name
+normalizeName name = '_': name
 
-data ParamDesc = ParamDescItem String | ParamDescList Bool [String] deriving (Eq, Show)
+uncapitalize :: String -> String
+uncapitalize []     = []
+uncapitalize (x:xs) = toLower x: xs
 
+data ParamDesc = ParamDescItem String
+    | ParamDescList Bool [String]
+    deriving (Eq, Show)
+data ResolveMode = ResolveTensor
+    | ResolveDataIter
+    deriving Eq
+
 type ResolvedType = (String, Type (), Type ())
-resolveHaskellType :: Bool -> String -> String -> Writer ([(String, String)], [ResolvedType], [ResolvedType], [ResolvedType]) ()
-resolveHaskellType asSymbol symname desc = do
+resolveHaskellType :: ResolveMode -> String -> String -> Writer ([(String, String)], [ResolvedType], [ResolvedType], [ResolvedType]) ()
+resolveHaskellType mode symname desc = do
     let fail   msg   = tell ([(symname, msg)], [], [], [])
     case readP_to_S typedesc desc of
         [(fields, "")] -> do
             let required = ParamDescItem "required" `elem` fields
                 attr = tyCon $ unQual $ name $ if required then "AttrReq" else "AttrOpt"
-                scalar hstyp = tell ([], [(symname_, attr, hstyp)], [], [])
-                symbol hstyp = tell ([], [], [(symname_, attr, hstyp)], [])
-                array  hstyp = tell ([], [], [], [(symname_, attr, hstyp)])
-                symname_ = normalizeName symname
-                --
-                -- symbol operators
-                --
-                -- operator can have only one argument of the type symbol or ndarray array
-                -- and not having any other argument of symbol or ndarray
-                -- besides the operator's info must definitely have a key_var_num_args, which
-                -- indicates an (might be additional) argument which should be passed to mxSymbolCreateAtomicSymbol.
-                handleSymbol (ParamDescItem "Symbol")              = symbol $ tyCon $ unQual $ name "SymbolHandle"
-                handleSymbol (ParamDescItem "NDArray-or-Symbol")   = symbol $ tyCon $ unQual $ name "SymbolHandle"
-                handleSymbol (ParamDescItem "Symbol[]")            = array $ tyList $ tyCon $ unQual $ name "SymbolHandle"
-                handleSymbol (ParamDescItem "NDArray-or-Symbol[]") = array $ tyList $ tyCon $ unQual $ name "SymbolHandle"
-                handleSymbol (ParamDescItem "Symbol or Symbol[]")  = array $ tyList $ tyCon $ unQual $ name "SymbolHandle"
-                handleSymbol (ParamDescItem "NDArray")             = fail $ printf "NDArrayHandle arg: %s" symname
-                handleSymbol t = fallThrough t
+                scalar hstyp      = tell ([], [(symname_, attr, hstyp)], [], [])
+                tensor_karg hstyp = tell ([], [], [(symname_, attr, hstyp)], [])
+                tensor_varg hstyp = tell ([], [], [], [(symname_, attr, hstyp)])
+                symname_ = uncapitalize symname
                 --
-                -- ndarray operators
+                -- tensor operators
                 --
-                handleNDArray (ParamDescItem "NDArray-or-Symbol")   = symbol $ tyCon $ unQual $ name "NDArrayHandle"
-                handleNDArray (ParamDescItem "NDArray-or-Symbol[]") = array $ tyList $ tyCon $ unQual $ name "NDArrayHandle"
-                handleNDArray (ParamDescItem "Symbol or Symbol[]")  = array $ tyList $ tyCon $ unQual $ name "NDArrayHandle"
-                handleNDArray (ParamDescItem "NDArray")             = symbol $ tyCon $ unQual $ name "NDArrayHandle"
-                handleNDArray (ParamDescItem "Symbol")              = fail $ printf "SymbolHandle arg: %s" symname
-                handleNDArray (ParamDescItem "Symbol[]")            = fail $ printf "SymbolHandle[] arg: %s" symname
-                handleNDArray t = fallThrough t
+                handleTensor (ParamDescItem "NDArray")             = tensor_karg $ tensorVar
+                handleTensor (ParamDescItem "NDArray-or-Symbol")   = tensor_karg $ tensorVar
+                handleTensor (ParamDescItem "NDArray-or-Symbol[]") = tensor_varg $ tyList $ tensorVar
+                handleTensor (ParamDescItem "Symbol")              = tensor_karg $ tensorVar
+                handleTensor (ParamDescItem "Symbol[]")            = tensor_varg $ tyList $ tensorVar
+                handleTensor (ParamDescItem "Symbol or Symbol[]")  = tensor_varg $ tyList $ tensorVar
+                handleTensor t = fallThrough t
 
                 fallThrough t = fail $ printf "Unknown type: arg %s(%s)." symname desc
 
@@ -334,7 +292,7 @@
                 ParamDescItem "float32"             -> scalar $ tyCon $ unQual $ name "Float"
                 -- real_t (from mshadow) is by default float.
                 ParamDescItem "real_t"              -> scalar $ tyCon $ unQual $ name "Float"
-                ParamDescItem "string"              -> scalar $ tyCon $ unQual $ name "String"
+                ParamDescItem "string"              -> scalar $ tyCon $ unQual $ name "Text"
                 ParamDescItem "int or None"         -> scalar $ tyApp (tyCon $ unQual $ name "Maybe") (tyCon $ unQual $ name "Int")
                 ParamDescItem "float or None"       -> scalar $ tyApp (tyCon $ unQual $ name "Maybe") (tyCon $ unQual $ name "Float")
                 ParamDescItem "double or None"      -> scalar $ tyApp (tyCon $ unQual $ name "Maybe") (tyCon $ unQual $ name "Double")
@@ -347,8 +305,9 @@
                         typ1 = tyApp (tyCon $ unQual $ name "EnumType") (tyPromotedList vsprom)
                         typ2 = tyApp (tyCon $ unQual $ name "Maybe") typ1
                     scalar $ if hasnone then typ2 else typ1
-                t -> (if asSymbol then handleSymbol else handleNDArray) t
-        other -> fail (printf "cannot parse type description: %s" desc)
+                t | mode == ResolveTensor -> handleTensor t
+                  | mode == ResolveDataIter -> fallThrough t
+        other -> fail (printf "cannot parse type description: %s. Result: %s" desc (show other))
 
 typedesc = do
     -- since 1.3, there are types starting with ',', and it implies 'int' type.
@@ -357,10 +316,12 @@
     eof
     return $ def ++ ds
   where
-    list1 = ParamDescList True  <$> between (string "{None,") (char '}') (sepBy (skipSpaces >> listItem) (char ','))
-    list2 = ParamDescList False <$> between (string "{") (char '}') (sepBy (skipSpaces >> listItem) (char ','))
-    listItem = between (char '\'') (char '\'') (munch1 (\c -> isAlphaNum c || c `elem` "_"))
-    item = ParamDescItem <$> munch1 (\c -> isAlphaNum c || c `elem` " _-()=[]<>'.")
+    list1 = ParamDescList True  <$> between (string "{None,") (char '}') (sepBy (skipSpaces >> strItem) (char ','))
+    list2 = ParamDescList False <$> between (string "{") (char '}') (sepBy (skipSpaces >> strItem) (char ','))
+    strItem = between (char '\'') (char '\'') (munch1 (\c -> isAlphaNum c || oneOf c "_-+-./"))
+    item = ParamDescItem <$> munch1 (\c -> isAlphaNum c || oneOf c " _-+()=[]<>./'")
+    oneOf :: Eq a => a -> [a] -> Bool
+    oneOf c wl = c `elem` wl
 
 unQual = UnQual ()
 unkindedVar = UnkindedVar ()
@@ -372,6 +333,7 @@
 tyFun = TyFun ()
 tySig names types = TypeSig () names types
 tyList = TyList ()
+tyTuple = TyTuple () Boxed
 tyVar = TyVar ()
 tyParen = TyParen ()
 
@@ -393,6 +355,8 @@
 tupleSection = TupleSection () Boxed
 
 con = Con ()
+
+expTypeSig = ExpTypeSig ()
 
 simpleImport mod = ImportDecl {
     importAnn = (),
diff --git a/fei-base.cabal b/fei-base.cabal
--- a/fei-base.cabal
+++ b/fei-base.cabal
@@ -1,6 +1,6 @@
-cabal-version:       2.2
+cabal-version:       2.4
 name:                fei-base
-version:             0.2.0.0
+version:             1.0.0
 synopsis:            FFI to MXNet
 description:         This package provides a FFI wrap of MXNet, including c-apis and symbol/array/executor operations.
 homepage:
@@ -13,48 +13,36 @@
 build-type:          Simple
 extra-source-files:  README.md
 
-Flag MXNet_1_5 {
-  Description: With MXNet 1.5.x operators
-  Default: True
-}
-
-Flag MXNet_1_4 {
-  Description: With MXNet 1.4.x operators
-  Default: False
-}
-
-Flag MXNet_1_3 {
-  Description: With MXNet 1.3.x operators
+Flag mxnet_geq_10600 {
+  Description: With MXNet 1.6.x operators
   Default: False
 }
 
-Flag MXNet_1_0 {
-  Description: With MXNet 1.0.x operators
-  Default: False
+Flag dummy {
+  Description: no operators
+  Default: True
 }
 
 library
   hs-source-dirs:      c-apis
-  if flag(MXNet_1_0) {
-      hs-source-dirs:  ops/1.0
-  }
-  elif flag(MXNet_1_3) {
-      hs-source-dirs:  ops/1.3
-  }
-  elif flag(MXNet_1_4) {
-      hs-source-dirs:  ops/1.4
+  if flag(mxnet_geq_10600) {
+      hs-source-dirs:  ops/1.6
   }
-  elif flag(MXNet_1_5) {
-      hs-source-dirs:  ops/1.5
+  elif flag(dummy) {
+      hs-source-dirs:  ops/dummy
   }
   build-depends:       base >= 4.7 && < 5,
-                       c2hs-extra == 0.1.0.1,
-                       tuple-ops == 0.0.0.3,
-                       vector >= 0.11 && < 0.13,
+                       tuple-ops == 0.0.0.4,
+                       deepseq,
                        constraints,
-                       repa
+                       lens,
+                       repa,
+                       vector,
+                       attoparsec,
+                       rio,
+                       store
   default-language:    Haskell2010
-  Build-tools:         c2hs
+  build-tool-depends:  c2hs:c2hs
   default-extensions:  FlexibleContexts,
                        GADTs,
                        StandaloneDeriving,
@@ -64,19 +52,25 @@
                        DataKinds,
                        TypeFamilies,
                        OverloadedLabels,
-                       TupleSections
+                       OverloadedStrings,
+                       LambdaCase,
+                       MultiWayIf,
+                       DoAndIfThenElse,
+                       NoImplicitPrelude,
+                       TupleSections,
+                       ScopedTypeVariables
   exposed-modules:     MXNet.Base,
                        MXNet.Base.Raw,
                        MXNet.Base.Types,
+                       MXNet.Base.ParserUtils,
                        MXNet.Base.Symbol,
                        MXNet.Base.NDArray,
+                       MXNet.Base.Tensor,
                        MXNet.Base.Executor,
                        MXNet.Base.Spec.Operator,
                        MXNet.Base.Spec.HMap
-  if flag(MXNet_1_0) || flag(MXNet_1_3) || flag(MXNet_1_4) || flag(MXnet_1_5) {
-    exposed-modules:   MXNet.Base.Operators.Symbol,
-                       MXNet.Base.Operators.NDArray
-  }
+                       MXNet.Base.Operators.Tensor,
+                       MXNet.Base.DataIter
   other-modules:       MXNet.Base.Raw.Common,
                        MXNet.Base.Raw.NDArray,
                        MXNet.Base.Raw.Symbol,
@@ -86,18 +80,30 @@
 
 executable mxnet-op-gen
   hs-source-dirs:      cmdline
+  hs-source-dirs:      c-apis
   main-is:             Main.hs
+  other-modules:       MXNet.Base.Raw.Common,
+                       MXNet.Base.Raw.NDArray,
+                       MXNet.Base.Raw.Symbol,
+                       MXNet.Base.Raw.Executor,
+                       MXNet.Base.Raw.DataIter
   build-depends:       base >= 4.7 && < 5,
                        optparse-applicative >= 0.14 && < 0.15,
                        haskell-src-exts >= 1.20,
                        hslogger >= 1.2,
-                       text >= 1.2.0 && < 1.3,
-                       mtl,
-                       filepath >= 1.4 && < 1.5,
-                       directory >= 1.3 && < 1.4,
-                       fei-base
+                       tuple-ops == 0.0.0.4,
+                       deepseq,
+                       lens,
+                       rio
   default-language:    Haskell2010
-  default-extensions:  FlexibleContexts
+  build-tool-depends:  c2hs:c2hs
+  default-extensions:  FlexibleContexts,
+                       StandaloneDeriving,
+                       DeriveGeneric,
+                       GeneralizedNewtypeDeriving,
+                       GADTs,
+                       OverloadedStrings,
+                       MultiWayIf
   extra-libraries:     mxnet
 
 source-repository head
diff --git a/ops/1.0/MXNet/Base/Operators/NDArray.hs b/ops/1.0/MXNet/Base/Operators/NDArray.hs
deleted file mode 100644
--- a/ops/1.0/MXNet/Base/Operators/NDArray.hs
+++ /dev/null
@@ -1,16434 +0,0 @@
-module MXNet.Base.Operators.NDArray where
-import MXNet.Base.Raw
-import MXNet.Base.Spec.Operator
-import MXNet.Base.Spec.HMap
-import Data.Maybe (catMaybes, fromMaybe)
-
-type instance ParameterList "broadcast_power(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_power ::
-                forall args . Fullfilled "broadcast_power(ndarray)" args =>
-                  ArgsHMap "broadcast_power(ndarray)" args -> IO [NDArrayHandle]
-broadcast_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_power_upd ::
-                    forall args . Fullfilled "broadcast_power(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "broadcast_power(ndarray)" args -> IO ()
-broadcast_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_power(ndarray)" =
-     '[]
-
-_backward_broadcast_power ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_power(ndarray)" args =>
-                            ArgsHMap "_backward_broadcast_power(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_broadcast_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_power_upd ::
-                              forall args .
-                                Fullfilled "_backward_broadcast_power(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_broadcast_power(ndarray)" args -> IO ()
-_backward_broadcast_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_maximum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_maximum ::
-                  forall args . Fullfilled "broadcast_maximum(ndarray)" args =>
-                    ArgsHMap "broadcast_maximum(ndarray)" args -> IO [NDArrayHandle]
-broadcast_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_maximum_upd ::
-                      forall args . Fullfilled "broadcast_maximum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "broadcast_maximum(ndarray)" args -> IO ()
-broadcast_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_maximum(ndarray)"
-     = '[]
-
-_backward_broadcast_maximum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_maximum(ndarray)" args =>
-                              ArgsHMap "_backward_broadcast_maximum(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_broadcast_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_maximum_upd ::
-                                forall args .
-                                  Fullfilled "_backward_broadcast_maximum(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> IO ()
-_backward_broadcast_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_minimum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_minimum ::
-                  forall args . Fullfilled "broadcast_minimum(ndarray)" args =>
-                    ArgsHMap "broadcast_minimum(ndarray)" args -> IO [NDArrayHandle]
-broadcast_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_minimum_upd ::
-                      forall args . Fullfilled "broadcast_minimum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "broadcast_minimum(ndarray)" args -> IO ()
-broadcast_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_minimum(ndarray)"
-     = '[]
-
-_backward_broadcast_minimum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_minimum(ndarray)" args =>
-                              ArgsHMap "_backward_broadcast_minimum(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_broadcast_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_minimum_upd ::
-                                forall args .
-                                  Fullfilled "_backward_broadcast_minimum(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> IO ()
-_backward_broadcast_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_hypot(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_hypot ::
-                forall args . Fullfilled "broadcast_hypot(ndarray)" args =>
-                  ArgsHMap "broadcast_hypot(ndarray)" args -> IO [NDArrayHandle]
-broadcast_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_hypot_upd ::
-                    forall args . Fullfilled "broadcast_hypot(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "broadcast_hypot(ndarray)" args -> IO ()
-broadcast_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_hypot(ndarray)" =
-     '[]
-
-_backward_broadcast_hypot ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_hypot(ndarray)" args =>
-                            ArgsHMap "_backward_broadcast_hypot(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_broadcast_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_hypot_upd ::
-                              forall args .
-                                Fullfilled "_backward_broadcast_hypot(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> IO ()
-_backward_broadcast_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_equal ::
-       forall args . Fullfilled "_equal(ndarray)" args =>
-         ArgsHMap "_equal(ndarray)" args -> IO [NDArrayHandle]
-_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_equal_upd ::
-           forall args . Fullfilled "_equal(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_equal(ndarray)" args -> IO ()
-_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_not_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_not_equal ::
-           forall args . Fullfilled "_not_equal(ndarray)" args =>
-             ArgsHMap "_not_equal(ndarray)" args -> IO [NDArrayHandle]
-_not_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_not_equal_upd ::
-               forall args . Fullfilled "_not_equal(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_not_equal(ndarray)" args -> IO ()
-_not_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_greater ::
-         forall args . Fullfilled "_greater(ndarray)" args =>
-           ArgsHMap "_greater(ndarray)" args -> IO [NDArrayHandle]
-_greater args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_upd ::
-             forall args . Fullfilled "_greater(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_greater(ndarray)" args -> IO ()
-_greater_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_greater_equal ::
-               forall args . Fullfilled "_greater_equal(ndarray)" args =>
-                 ArgsHMap "_greater_equal(ndarray)" args -> IO [NDArrayHandle]
-_greater_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_equal_upd ::
-                   forall args . Fullfilled "_greater_equal(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_greater_equal(ndarray)" args -> IO ()
-_greater_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_lesser ::
-        forall args . Fullfilled "_lesser(ndarray)" args =>
-          ArgsHMap "_lesser(ndarray)" args -> IO [NDArrayHandle]
-_lesser args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_upd ::
-            forall args . Fullfilled "_lesser(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_lesser(ndarray)" args -> IO ()
-_lesser_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_lesser_equal ::
-              forall args . Fullfilled "_lesser_equal(ndarray)" args =>
-                ArgsHMap "_lesser_equal(ndarray)" args -> IO [NDArrayHandle]
-_lesser_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_equal_upd ::
-                  forall args . Fullfilled "_lesser_equal(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_lesser_equal(ndarray)" args -> IO ()
-_lesser_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_power(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_power ::
-       forall args . Fullfilled "_power(ndarray)" args =>
-         ArgsHMap "_power(ndarray)" args -> IO [NDArrayHandle]
-_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_power_upd ::
-           forall args . Fullfilled "_power(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_power(ndarray)" args -> IO ()
-_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_power(ndarray)" = '[]
-
-_backward_power ::
-                forall args . Fullfilled "_backward_power(ndarray)" args =>
-                  ArgsHMap "_backward_power(ndarray)" args -> IO [NDArrayHandle]
-_backward_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_power_upd ::
-                    forall args . Fullfilled "_backward_power(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_power(ndarray)" args -> IO ()
-_backward_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_maximum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_maximum ::
-         forall args . Fullfilled "_maximum(ndarray)" args =>
-           ArgsHMap "_maximum(ndarray)" args -> IO [NDArrayHandle]
-_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_maximum_upd ::
-             forall args . Fullfilled "_maximum(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_maximum(ndarray)" args -> IO ()
-_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_maximum(ndarray)" = '[]
-
-_backward_maximum ::
-                  forall args . Fullfilled "_backward_maximum(ndarray)" args =>
-                    ArgsHMap "_backward_maximum(ndarray)" args -> IO [NDArrayHandle]
-_backward_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_maximum_upd ::
-                      forall args . Fullfilled "_backward_maximum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_maximum(ndarray)" args -> IO ()
-_backward_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_minimum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_minimum ::
-         forall args . Fullfilled "_minimum(ndarray)" args =>
-           ArgsHMap "_minimum(ndarray)" args -> IO [NDArrayHandle]
-_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_minimum_upd ::
-             forall args . Fullfilled "_minimum(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_minimum(ndarray)" args -> IO ()
-_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_minimum(ndarray)" = '[]
-
-_backward_minimum ::
-                  forall args . Fullfilled "_backward_minimum(ndarray)" args =>
-                    ArgsHMap "_backward_minimum(ndarray)" args -> IO [NDArrayHandle]
-_backward_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_minimum_upd ::
-                      forall args . Fullfilled "_backward_minimum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_minimum(ndarray)" args -> IO ()
-_backward_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_hypot(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_hypot ::
-       forall args . Fullfilled "_hypot(ndarray)" args =>
-         ArgsHMap "_hypot(ndarray)" args -> IO [NDArrayHandle]
-_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_hypot_upd ::
-           forall args . Fullfilled "_hypot(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_hypot(ndarray)" args -> IO ()
-_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_hypot(ndarray)" = '[]
-
-_backward_hypot ::
-                forall args . Fullfilled "_backward_hypot(ndarray)" args =>
-                  ArgsHMap "_backward_hypot(ndarray)" args -> IO [NDArrayHandle]
-_backward_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_hypot_upd ::
-                    forall args . Fullfilled "_backward_hypot(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_hypot(ndarray)" args -> IO ()
-_backward_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_square_sum(ndarray)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-_square_sum ::
-            forall args . Fullfilled "_square_sum(ndarray)" args =>
-              ArgsHMap "_square_sum(ndarray)" args -> IO [NDArrayHandle]
-_square_sum args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_square_sum_upd ::
-                forall args . Fullfilled "_square_sum(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_square_sum(ndarray)" args -> IO ()
-_square_sum_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_square_sum(ndarray)" = '[]
-
-_backward_square_sum ::
-                     forall args . Fullfilled "_backward_square_sum(ndarray)" args =>
-                       ArgsHMap "_backward_square_sum(ndarray)" args -> IO [NDArrayHandle]
-_backward_square_sum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_square_sum_upd ::
-                         forall args . Fullfilled "_backward_square_sum(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_square_sum(ndarray)" args -> IO ()
-_backward_square_sum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "add_n(ndarray)" =
-     '[ '("args", AttrOpt [NDArrayHandle])]
-
-add_n ::
-      forall args . Fullfilled "add_n(ndarray)" args =>
-        ArgsHMap "add_n(ndarray)" args -> IO [NDArrayHandle]
-add_n args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "add_n"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-add_n_upd ::
-          forall args . Fullfilled "add_n(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "add_n(ndarray)" args -> IO ()
-add_n_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "add_n"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_zeros(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-
-_zeros ::
-       forall args . Fullfilled "_zeros(ndarray)" args =>
-         ArgsHMap "_zeros(ndarray)" args -> IO [NDArrayHandle]
-_zeros args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_zeros_upd ::
-           forall args . Fullfilled "_zeros(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_zeros(ndarray)" args -> IO ()
-_zeros_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_ones(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-
-_ones ::
-      forall args . Fullfilled "_ones(ndarray)" args =>
-        ArgsHMap "_ones(ndarray)" args -> IO [NDArrayHandle]
-_ones args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ones"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_ones_upd ::
-          forall args . Fullfilled "_ones(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_ones(ndarray)" args -> IO ()
-_ones_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ones"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_full(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("value", AttrReq Double)]
-
-_full ::
-      forall args . Fullfilled "_full(ndarray)" args =>
-        ArgsHMap "_full(ndarray)" args -> IO [NDArrayHandle]
-_full args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_full"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_full_upd ::
-          forall args . Fullfilled "_full(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_full(ndarray)" args -> IO ()
-_full_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_full"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_arange(ndarray)" =
-     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),
-        '("step", AttrOpt Double), '("repeat", AttrOpt Int),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "uint8"]))]
-
-_arange ::
-        forall args . Fullfilled "_arange(ndarray)" args =>
-          ArgsHMap "_arange(ndarray)" args -> IO [NDArrayHandle]
-_arange args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_arange"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_arange_upd ::
-            forall args . Fullfilled "_arange(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_arange(ndarray)" args -> IO ()
-_arange_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_arange"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "zeros_like(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-zeros_like ::
-           forall args . Fullfilled "zeros_like(ndarray)" args =>
-             ArgsHMap "zeros_like(ndarray)" args -> IO [NDArrayHandle]
-zeros_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "zeros_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-zeros_like_upd ::
-               forall args . Fullfilled "zeros_like(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "zeros_like(ndarray)" args -> IO ()
-zeros_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "zeros_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ones_like(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-ones_like ::
-          forall args . Fullfilled "ones_like(ndarray)" args =>
-            ArgsHMap "ones_like(ndarray)" args -> IO [NDArrayHandle]
-ones_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ones_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ones_like_upd ::
-              forall args . Fullfilled "ones_like(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "ones_like(ndarray)" args -> IO ()
-ones_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ones_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_add(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_add ::
-              forall args . Fullfilled "broadcast_add(ndarray)" args =>
-                ArgsHMap "broadcast_add(ndarray)" args -> IO [NDArrayHandle]
-broadcast_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_add_upd ::
-                  forall args . Fullfilled "broadcast_add(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_add(ndarray)" args -> IO ()
-broadcast_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_add(ndarray)" =
-     '[]
-
-_backward_broadcast_add ::
-                        forall args . Fullfilled "_backward_broadcast_add(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_add(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_add_upd ::
-                            forall args . Fullfilled "_backward_broadcast_add(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_add(ndarray)" args -> IO ()
-_backward_broadcast_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_sub(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_sub ::
-              forall args . Fullfilled "broadcast_sub(ndarray)" args =>
-                ArgsHMap "broadcast_sub(ndarray)" args -> IO [NDArrayHandle]
-broadcast_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_sub_upd ::
-                  forall args . Fullfilled "broadcast_sub(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_sub(ndarray)" args -> IO ()
-broadcast_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_sub(ndarray)" =
-     '[]
-
-_backward_broadcast_sub ::
-                        forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_sub(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_sub_upd ::
-                            forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_sub(ndarray)" args -> IO ()
-_backward_broadcast_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_mul(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_mul ::
-              forall args . Fullfilled "broadcast_mul(ndarray)" args =>
-                ArgsHMap "broadcast_mul(ndarray)" args -> IO [NDArrayHandle]
-broadcast_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_mul_upd ::
-                  forall args . Fullfilled "broadcast_mul(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_mul(ndarray)" args -> IO ()
-broadcast_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_mul(ndarray)" =
-     '[]
-
-_backward_broadcast_mul ::
-                        forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_mul(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_mul_upd ::
-                            forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_mul(ndarray)" args -> IO ()
-_backward_broadcast_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_div(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_div ::
-              forall args . Fullfilled "broadcast_div(ndarray)" args =>
-                ArgsHMap "broadcast_div(ndarray)" args -> IO [NDArrayHandle]
-broadcast_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_div_upd ::
-                  forall args . Fullfilled "broadcast_div(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_div(ndarray)" args -> IO ()
-broadcast_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_div(ndarray)" =
-     '[]
-
-_backward_broadcast_div ::
-                        forall args . Fullfilled "_backward_broadcast_div(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_div(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_div_upd ::
-                            forall args . Fullfilled "_backward_broadcast_div(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_div(ndarray)" args -> IO ()
-_backward_broadcast_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_mod(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_mod ::
-              forall args . Fullfilled "broadcast_mod(ndarray)" args =>
-                ArgsHMap "broadcast_mod(ndarray)" args -> IO [NDArrayHandle]
-broadcast_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_mod_upd ::
-                  forall args . Fullfilled "broadcast_mod(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_mod(ndarray)" args -> IO ()
-broadcast_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_mod(ndarray)" =
-     '[]
-
-_backward_broadcast_mod ::
-                        forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_mod(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_mod_upd ::
-                            forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_mod(ndarray)" args -> IO ()
-_backward_broadcast_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_gemm(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),
-        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle),
-        '("_C", AttrOpt NDArrayHandle)]
-
-_linalg_gemm ::
-             forall args . Fullfilled "_linalg_gemm(ndarray)" args =>
-               ArgsHMap "_linalg_gemm(ndarray)" args -> IO [NDArrayHandle]
-_linalg_gemm args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle),
-               ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_gemm_upd ::
-                 forall args . Fullfilled "_linalg_gemm(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_gemm(ndarray)" args -> IO ()
-_linalg_gemm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle),
-               ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_gemm(ndarray)" = '[]
-
-_backward_linalg_gemm ::
-                      forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_gemm(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_gemm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_gemm_upd ::
-                          forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_gemm(ndarray)" args -> IO ()
-_backward_linalg_gemm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_gemm2(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("_A", AttrOpt NDArrayHandle),
-        '("_B", AttrOpt NDArrayHandle)]
-
-_linalg_gemm2 ::
-              forall args . Fullfilled "_linalg_gemm2(ndarray)" args =>
-                ArgsHMap "_linalg_gemm2(ndarray)" args -> IO [NDArrayHandle]
-_linalg_gemm2 args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_gemm2_upd ::
-                  forall args . Fullfilled "_linalg_gemm2(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_gemm2(ndarray)" args -> IO ()
-_linalg_gemm2_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_gemm2(ndarray)" = '[]
-
-_backward_linalg_gemm2 ::
-                       forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_gemm2(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_gemm2 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_gemm2_upd ::
-                           forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> IO ()
-_backward_linalg_gemm2_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_potrf(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_potrf ::
-              forall args . Fullfilled "_linalg_potrf(ndarray)" args =>
-                ArgsHMap "_linalg_potrf(ndarray)" args -> IO [NDArrayHandle]
-_linalg_potrf args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_potrf_upd ::
-                  forall args . Fullfilled "_linalg_potrf(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_potrf(ndarray)" args -> IO ()
-_linalg_potrf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_potrf(ndarray)" = '[]
-
-_backward_linalg_potrf ::
-                       forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_potrf(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_potrf args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_potrf_upd ::
-                           forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_potrf(ndarray)" args -> IO ()
-_backward_linalg_potrf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_potri(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_potri ::
-              forall args . Fullfilled "_linalg_potri(ndarray)" args =>
-                ArgsHMap "_linalg_potri(ndarray)" args -> IO [NDArrayHandle]
-_linalg_potri args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_potri_upd ::
-                  forall args . Fullfilled "_linalg_potri(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_potri(ndarray)" args -> IO ()
-_linalg_potri_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_potri(ndarray)" = '[]
-
-_backward_linalg_potri ::
-                       forall args . Fullfilled "_backward_linalg_potri(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_potri(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_potri args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_potri_upd ::
-                           forall args . Fullfilled "_backward_linalg_potri(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_potri(ndarray)" args -> IO ()
-_backward_linalg_potri_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_trmm(ndarray)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("_A", AttrOpt NDArrayHandle),
-        '("_B", AttrOpt NDArrayHandle)]
-
-_linalg_trmm ::
-             forall args . Fullfilled "_linalg_trmm(ndarray)" args =>
-               ArgsHMap "_linalg_trmm(ndarray)" args -> IO [NDArrayHandle]
-_linalg_trmm args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_trmm_upd ::
-                 forall args . Fullfilled "_linalg_trmm(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_trmm(ndarray)" args -> IO ()
-_linalg_trmm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_trmm(ndarray)" = '[]
-
-_backward_linalg_trmm ::
-                      forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_trmm(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_trmm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_trmm_upd ::
-                          forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_trmm(ndarray)" args -> IO ()
-_backward_linalg_trmm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_trsm(ndarray)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("_A", AttrOpt NDArrayHandle),
-        '("_B", AttrOpt NDArrayHandle)]
-
-_linalg_trsm ::
-             forall args . Fullfilled "_linalg_trsm(ndarray)" args =>
-               ArgsHMap "_linalg_trsm(ndarray)" args -> IO [NDArrayHandle]
-_linalg_trsm args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_trsm_upd ::
-                 forall args . Fullfilled "_linalg_trsm(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_trsm(ndarray)" args -> IO ()
-_linalg_trsm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_trsm(ndarray)" = '[]
-
-_backward_linalg_trsm ::
-                      forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_trsm(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_trsm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_trsm_upd ::
-                          forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_trsm(ndarray)" args -> IO ()
-_backward_linalg_trsm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_sumlogdiag(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_sumlogdiag ::
-                   forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args =>
-                     ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO [NDArrayHandle]
-_linalg_sumlogdiag args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_sumlogdiag_upd ::
-                       forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO ()
-_linalg_sumlogdiag_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_sumlogdiag(ndarray)"
-     = '[]
-
-_backward_linalg_sumlogdiag ::
-                            forall args .
-                              Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args =>
-                              ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_linalg_sumlogdiag args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_sumlogdiag_upd ::
-                                forall args .
-                                  Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> IO ()
-_backward_linalg_sumlogdiag_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_syrk(ndarray)" =
-     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_syrk ::
-             forall args . Fullfilled "_linalg_syrk(ndarray)" args =>
-               ArgsHMap "_linalg_syrk(ndarray)" args -> IO [NDArrayHandle]
-_linalg_syrk args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_syrk_upd ::
-                 forall args . Fullfilled "_linalg_syrk(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_syrk(ndarray)" args -> IO ()
-_linalg_syrk_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_syrk(ndarray)" = '[]
-
-_backward_linalg_syrk ::
-                      forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_syrk(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_syrk args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_syrk_upd ::
-                          forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_syrk(ndarray)" args -> IO ()
-_backward_linalg_syrk_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_gelqf(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_gelqf ::
-              forall args . Fullfilled "_linalg_gelqf(ndarray)" args =>
-                ArgsHMap "_linalg_gelqf(ndarray)" args -> IO [NDArrayHandle]
-_linalg_gelqf args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_gelqf_upd ::
-                  forall args . Fullfilled "_linalg_gelqf(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_gelqf(ndarray)" args -> IO ()
-_linalg_gelqf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_gelqf(ndarray)" = '[]
-
-_backward_linalg_gelqf ::
-                       forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_gelqf(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_gelqf args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_gelqf_upd ::
-                           forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> IO ()
-_backward_linalg_gelqf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_syevd(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_syevd ::
-              forall args . Fullfilled "_linalg_syevd(ndarray)" args =>
-                ArgsHMap "_linalg_syevd(ndarray)" args -> IO [NDArrayHandle]
-_linalg_syevd args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_syevd_upd ::
-                  forall args . Fullfilled "_linalg_syevd(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_syevd(ndarray)" args -> IO ()
-_linalg_syevd_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_syevd(ndarray)" = '[]
-
-_backward_linalg_syevd ::
-                       forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_syevd(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_syevd args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_syevd_upd ::
-                           forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_syevd(ndarray)" args -> IO ()
-_backward_linalg_syevd_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cast_storage(ndarray)" =
-     '[ '("stype",
-          AttrReq (EnumType '["csr", "default", "row_sparse"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-cast_storage ::
-             forall args . Fullfilled "cast_storage(ndarray)" args =>
-               ArgsHMap "cast_storage(ndarray)" args -> IO [NDArrayHandle]
-cast_storage args
-  = let scalarArgs
-          = catMaybes
-              [("stype",) . showValue <$>
-                 (args !? #stype ::
-                    Maybe (EnumType '["csr", "default", "row_sparse"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cast_storage"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cast_storage_upd ::
-                 forall args . Fullfilled "cast_storage(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "cast_storage(ndarray)" args -> IO ()
-cast_storage_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("stype",) . showValue <$>
-                 (args !? #stype ::
-                    Maybe (EnumType '["csr", "default", "row_sparse"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cast_storage"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_equal_scalar ::
-              forall args . Fullfilled "_equal_scalar(ndarray)" args =>
-                ArgsHMap "_equal_scalar(ndarray)" args -> IO [NDArrayHandle]
-_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_equal_scalar_upd ::
-                  forall args . Fullfilled "_equal_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_equal_scalar(ndarray)" args -> IO ()
-_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_not_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_not_equal_scalar ::
-                  forall args . Fullfilled "_not_equal_scalar(ndarray)" args =>
-                    ArgsHMap "_not_equal_scalar(ndarray)" args -> IO [NDArrayHandle]
-_not_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_not_equal_scalar_upd ::
-                      forall args . Fullfilled "_not_equal_scalar(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_not_equal_scalar(ndarray)" args -> IO ()
-_not_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_greater_scalar ::
-                forall args . Fullfilled "_greater_scalar(ndarray)" args =>
-                  ArgsHMap "_greater_scalar(ndarray)" args -> IO [NDArrayHandle]
-_greater_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_scalar_upd ::
-                    forall args . Fullfilled "_greater_scalar(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_greater_scalar(ndarray)" args -> IO ()
-_greater_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_greater_equal_scalar ::
-                      forall args . Fullfilled "_greater_equal_scalar(ndarray)" args =>
-                        ArgsHMap "_greater_equal_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_greater_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_equal_scalar_upd ::
-                          forall args . Fullfilled "_greater_equal_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_greater_equal_scalar(ndarray)" args -> IO ()
-_greater_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_lesser_scalar ::
-               forall args . Fullfilled "_lesser_scalar(ndarray)" args =>
-                 ArgsHMap "_lesser_scalar(ndarray)" args -> IO [NDArrayHandle]
-_lesser_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_scalar_upd ::
-                   forall args . Fullfilled "_lesser_scalar(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_lesser_scalar(ndarray)" args -> IO ()
-_lesser_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_lesser_equal_scalar ::
-                     forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args =>
-                       ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO [NDArrayHandle]
-_lesser_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_equal_scalar_upd ::
-                         forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO ()
-_lesser_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "relu(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-relu ::
-     forall args . Fullfilled "relu(ndarray)" args =>
-       ArgsHMap "relu(ndarray)" args -> IO [NDArrayHandle]
-relu args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-relu_upd ::
-         forall args . Fullfilled "relu(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "relu(ndarray)" args -> IO ()
-relu_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_relu(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_relu ::
-               forall args . Fullfilled "_backward_relu(ndarray)" args =>
-                 ArgsHMap "_backward_relu(ndarray)" args -> IO [NDArrayHandle]
-_backward_relu args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_relu_upd ::
-                   forall args . Fullfilled "_backward_relu(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_relu(ndarray)" args -> IO ()
-_backward_relu_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sigmoid(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sigmoid ::
-        forall args . Fullfilled "sigmoid(ndarray)" args =>
-          ArgsHMap "sigmoid(ndarray)" args -> IO [NDArrayHandle]
-sigmoid args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sigmoid_upd ::
-            forall args . Fullfilled "sigmoid(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "sigmoid(ndarray)" args -> IO ()
-sigmoid_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sigmoid(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sigmoid ::
-                  forall args . Fullfilled "_backward_sigmoid(ndarray)" args =>
-                    ArgsHMap "_backward_sigmoid(ndarray)" args -> IO [NDArrayHandle]
-_backward_sigmoid args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sigmoid_upd ::
-                      forall args . Fullfilled "_backward_sigmoid(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_sigmoid(ndarray)" args -> IO ()
-_backward_sigmoid_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_copy(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_copy ::
-      forall args . Fullfilled "_copy(ndarray)" args =>
-        ArgsHMap "_copy(ndarray)" args -> IO [NDArrayHandle]
-_copy args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_copy_upd ::
-          forall args . Fullfilled "_copy(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_copy(ndarray)" args -> IO ()
-_copy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_copy(ndarray)" = '[]
-
-_backward_copy ::
-               forall args . Fullfilled "_backward_copy(ndarray)" args =>
-                 ArgsHMap "_backward_copy(ndarray)" args -> IO [NDArrayHandle]
-_backward_copy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_copy_upd ::
-                   forall args . Fullfilled "_backward_copy(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_copy(ndarray)" args -> IO ()
-_backward_copy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BlockGrad(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_BlockGrad ::
-           forall args . Fullfilled "_BlockGrad(ndarray)" args =>
-             ArgsHMap "_BlockGrad(ndarray)" args -> IO [NDArrayHandle]
-_BlockGrad args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BlockGrad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BlockGrad_upd ::
-               forall args . Fullfilled "_BlockGrad(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_BlockGrad(ndarray)" args -> IO ()
-_BlockGrad_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BlockGrad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "make_loss(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-make_loss ::
-          forall args . Fullfilled "make_loss(ndarray)" args =>
-            ArgsHMap "make_loss(ndarray)" args -> IO [NDArrayHandle]
-make_loss args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "make_loss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-make_loss_upd ::
-              forall args . Fullfilled "make_loss(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "make_loss(ndarray)" args -> IO ()
-make_loss_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "make_loss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_identity_with_attr_like_rhs(ndarray)"
-     =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_identity_with_attr_like_rhs ::
-                             forall args .
-                               Fullfilled "_identity_with_attr_like_rhs(ndarray)" args =>
-                               ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_identity_with_attr_like_rhs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_identity_with_attr_like_rhs_upd ::
-                                 forall args .
-                                   Fullfilled "_identity_with_attr_like_rhs(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> IO ()
-_identity_with_attr_like_rhs_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "reshape_like(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-reshape_like ::
-             forall args . Fullfilled "reshape_like(ndarray)" args =>
-               ArgsHMap "reshape_like(ndarray)" args -> IO [NDArrayHandle]
-reshape_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reshape_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-reshape_like_upd ::
-                 forall args . Fullfilled "reshape_like(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "reshape_like(ndarray)" args -> IO ()
-reshape_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reshape_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Cast(ndarray)" =
-     '[ '("dtype",
-          AttrReq
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Cast ::
-      forall args . Fullfilled "_Cast(ndarray)" args =>
-        ArgsHMap "_Cast(ndarray)" args -> IO [NDArrayHandle]
-_Cast args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Cast_upd ::
-          forall args . Fullfilled "_Cast(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_Cast(ndarray)" args -> IO ()
-_Cast_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cast(ndarray)" = '[]
-
-_backward_cast ::
-               forall args . Fullfilled "_backward_cast(ndarray)" args =>
-                 ArgsHMap "_backward_cast(ndarray)" args -> IO [NDArrayHandle]
-_backward_cast args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cast_upd ::
-                   forall args . Fullfilled "_backward_cast(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cast(ndarray)" args -> IO ()
-_backward_cast_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "negative(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-negative ::
-         forall args . Fullfilled "negative(ndarray)" args =>
-           ArgsHMap "negative(ndarray)" args -> IO [NDArrayHandle]
-negative args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "negative"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-negative_upd ::
-             forall args . Fullfilled "negative(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "negative(ndarray)" args -> IO ()
-negative_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "negative"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "reciprocal(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-reciprocal ::
-           forall args . Fullfilled "reciprocal(ndarray)" args =>
-             ArgsHMap "reciprocal(ndarray)" args -> IO [NDArrayHandle]
-reciprocal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-reciprocal_upd ::
-               forall args . Fullfilled "reciprocal(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "reciprocal(ndarray)" args -> IO ()
-reciprocal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_reciprocal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_reciprocal ::
-                     forall args . Fullfilled "_backward_reciprocal(ndarray)" args =>
-                       ArgsHMap "_backward_reciprocal(ndarray)" args -> IO [NDArrayHandle]
-_backward_reciprocal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_reciprocal_upd ::
-                         forall args . Fullfilled "_backward_reciprocal(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_reciprocal(ndarray)" args -> IO ()
-_backward_reciprocal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "abs(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-abs ::
-    forall args . Fullfilled "abs(ndarray)" args =>
-      ArgsHMap "abs(ndarray)" args -> IO [NDArrayHandle]
-abs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-abs_upd ::
-        forall args . Fullfilled "abs(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "abs(ndarray)" args -> IO ()
-abs_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_abs(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_abs ::
-              forall args . Fullfilled "_backward_abs(ndarray)" args =>
-                ArgsHMap "_backward_abs(ndarray)" args -> IO [NDArrayHandle]
-_backward_abs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_abs_upd ::
-                  forall args . Fullfilled "_backward_abs(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_abs(ndarray)" args -> IO ()
-_backward_abs_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sign(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sign ::
-     forall args . Fullfilled "sign(ndarray)" args =>
-       ArgsHMap "sign(ndarray)" args -> IO [NDArrayHandle]
-sign args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sign_upd ::
-         forall args . Fullfilled "sign(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sign(ndarray)" args -> IO ()
-sign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sign(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sign ::
-               forall args . Fullfilled "_backward_sign(ndarray)" args =>
-                 ArgsHMap "_backward_sign(ndarray)" args -> IO [NDArrayHandle]
-_backward_sign args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sign_upd ::
-                   forall args . Fullfilled "_backward_sign(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_sign(ndarray)" args -> IO ()
-_backward_sign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "round(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-round ::
-      forall args . Fullfilled "round(ndarray)" args =>
-        ArgsHMap "round(ndarray)" args -> IO [NDArrayHandle]
-round args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "round"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-round_upd ::
-          forall args . Fullfilled "round(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "round(ndarray)" args -> IO ()
-round_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "round"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rint(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-rint ::
-     forall args . Fullfilled "rint(ndarray)" args =>
-       ArgsHMap "rint(ndarray)" args -> IO [NDArrayHandle]
-rint args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rint"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rint_upd ::
-         forall args . Fullfilled "rint(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "rint(ndarray)" args -> IO ()
-rint_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rint"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ceil(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-ceil ::
-     forall args . Fullfilled "ceil(ndarray)" args =>
-       ArgsHMap "ceil(ndarray)" args -> IO [NDArrayHandle]
-ceil args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ceil"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ceil_upd ::
-         forall args . Fullfilled "ceil(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "ceil(ndarray)" args -> IO ()
-ceil_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ceil"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "floor(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-floor ::
-      forall args . Fullfilled "floor(ndarray)" args =>
-        ArgsHMap "floor(ndarray)" args -> IO [NDArrayHandle]
-floor args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "floor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-floor_upd ::
-          forall args . Fullfilled "floor(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "floor(ndarray)" args -> IO ()
-floor_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "floor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "trunc(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-trunc ::
-      forall args . Fullfilled "trunc(ndarray)" args =>
-        ArgsHMap "trunc(ndarray)" args -> IO [NDArrayHandle]
-trunc args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "trunc"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-trunc_upd ::
-          forall args . Fullfilled "trunc(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "trunc(ndarray)" args -> IO ()
-trunc_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "trunc"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "fix(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-fix ::
-    forall args . Fullfilled "fix(ndarray)" args =>
-      ArgsHMap "fix(ndarray)" args -> IO [NDArrayHandle]
-fix args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fix"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-fix_upd ::
-        forall args . Fullfilled "fix(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "fix(ndarray)" args -> IO ()
-fix_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fix"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "square(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-square ::
-       forall args . Fullfilled "square(ndarray)" args =>
-         ArgsHMap "square(ndarray)" args -> IO [NDArrayHandle]
-square args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-square_upd ::
-           forall args . Fullfilled "square(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "square(ndarray)" args -> IO ()
-square_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_square(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_square ::
-                 forall args . Fullfilled "_backward_square(ndarray)" args =>
-                   ArgsHMap "_backward_square(ndarray)" args -> IO [NDArrayHandle]
-_backward_square args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_square_upd ::
-                     forall args . Fullfilled "_backward_square(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_square(ndarray)" args -> IO ()
-_backward_square_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sqrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sqrt ::
-     forall args . Fullfilled "sqrt(ndarray)" args =>
-       ArgsHMap "sqrt(ndarray)" args -> IO [NDArrayHandle]
-sqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sqrt_upd ::
-         forall args . Fullfilled "sqrt(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sqrt(ndarray)" args -> IO ()
-sqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sqrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sqrt ::
-               forall args . Fullfilled "_backward_sqrt(ndarray)" args =>
-                 ArgsHMap "_backward_sqrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_sqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sqrt_upd ::
-                   forall args . Fullfilled "_backward_sqrt(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_sqrt(ndarray)" args -> IO ()
-_backward_sqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rsqrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-rsqrt ::
-      forall args . Fullfilled "rsqrt(ndarray)" args =>
-        ArgsHMap "rsqrt(ndarray)" args -> IO [NDArrayHandle]
-rsqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rsqrt_upd ::
-          forall args . Fullfilled "rsqrt(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "rsqrt(ndarray)" args -> IO ()
-rsqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rsqrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rsqrt ::
-                forall args . Fullfilled "_backward_rsqrt(ndarray)" args =>
-                  ArgsHMap "_backward_rsqrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_rsqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rsqrt_upd ::
-                    forall args . Fullfilled "_backward_rsqrt(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_rsqrt(ndarray)" args -> IO ()
-_backward_rsqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cbrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-cbrt ::
-     forall args . Fullfilled "cbrt(ndarray)" args =>
-       ArgsHMap "cbrt(ndarray)" args -> IO [NDArrayHandle]
-cbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cbrt_upd ::
-         forall args . Fullfilled "cbrt(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "cbrt(ndarray)" args -> IO ()
-cbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cbrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_cbrt ::
-               forall args . Fullfilled "_backward_cbrt(ndarray)" args =>
-                 ArgsHMap "_backward_cbrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_cbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cbrt_upd ::
-                   forall args . Fullfilled "_backward_cbrt(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cbrt(ndarray)" args -> IO ()
-_backward_cbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rcbrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-rcbrt ::
-      forall args . Fullfilled "rcbrt(ndarray)" args =>
-        ArgsHMap "rcbrt(ndarray)" args -> IO [NDArrayHandle]
-rcbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rcbrt_upd ::
-          forall args . Fullfilled "rcbrt(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "rcbrt(ndarray)" args -> IO ()
-rcbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rcbrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rcbrt ::
-                forall args . Fullfilled "_backward_rcbrt(ndarray)" args =>
-                  ArgsHMap "_backward_rcbrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_rcbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rcbrt_upd ::
-                    forall args . Fullfilled "_backward_rcbrt(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_rcbrt(ndarray)" args -> IO ()
-_backward_rcbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "exp(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-exp ::
-    forall args . Fullfilled "exp(ndarray)" args =>
-      ArgsHMap "exp(ndarray)" args -> IO [NDArrayHandle]
-exp args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "exp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-exp_upd ::
-        forall args . Fullfilled "exp(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "exp(ndarray)" args -> IO ()
-exp_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "exp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log ::
-    forall args . Fullfilled "log(ndarray)" args =>
-      ArgsHMap "log(ndarray)" args -> IO [NDArrayHandle]
-log args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log_upd ::
-        forall args . Fullfilled "log(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "log(ndarray)" args -> IO ()
-log_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log10(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log10 ::
-      forall args . Fullfilled "log10(ndarray)" args =>
-        ArgsHMap "log10(ndarray)" args -> IO [NDArrayHandle]
-log10 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log10_upd ::
-          forall args . Fullfilled "log10(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "log10(ndarray)" args -> IO ()
-log10_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log2(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log2 ::
-     forall args . Fullfilled "log2(ndarray)" args =>
-       ArgsHMap "log2(ndarray)" args -> IO [NDArrayHandle]
-log2 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log2_upd ::
-         forall args . Fullfilled "log2(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "log2(ndarray)" args -> IO ()
-log2_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log ::
-              forall args . Fullfilled "_backward_log(ndarray)" args =>
-                ArgsHMap "_backward_log(ndarray)" args -> IO [NDArrayHandle]
-_backward_log args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log_upd ::
-                  forall args . Fullfilled "_backward_log(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_log(ndarray)" args -> IO ()
-_backward_log_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log10(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log10 ::
-                forall args . Fullfilled "_backward_log10(ndarray)" args =>
-                  ArgsHMap "_backward_log10(ndarray)" args -> IO [NDArrayHandle]
-_backward_log10 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log10_upd ::
-                    forall args . Fullfilled "_backward_log10(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_log10(ndarray)" args -> IO ()
-_backward_log10_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log2(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log2 ::
-               forall args . Fullfilled "_backward_log2(ndarray)" args =>
-                 ArgsHMap "_backward_log2(ndarray)" args -> IO [NDArrayHandle]
-_backward_log2 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log2_upd ::
-                   forall args . Fullfilled "_backward_log2(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_log2(ndarray)" args -> IO ()
-_backward_log2_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log1p(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log1p ::
-      forall args . Fullfilled "log1p(ndarray)" args =>
-        ArgsHMap "log1p(ndarray)" args -> IO [NDArrayHandle]
-log1p args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log1p_upd ::
-          forall args . Fullfilled "log1p(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "log1p(ndarray)" args -> IO ()
-log1p_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log1p(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log1p ::
-                forall args . Fullfilled "_backward_log1p(ndarray)" args =>
-                  ArgsHMap "_backward_log1p(ndarray)" args -> IO [NDArrayHandle]
-_backward_log1p args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log1p_upd ::
-                    forall args . Fullfilled "_backward_log1p(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_log1p(ndarray)" args -> IO ()
-_backward_log1p_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "expm1(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-expm1 ::
-      forall args . Fullfilled "expm1(ndarray)" args =>
-        ArgsHMap "expm1(ndarray)" args -> IO [NDArrayHandle]
-expm1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-expm1_upd ::
-          forall args . Fullfilled "expm1(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "expm1(ndarray)" args -> IO ()
-expm1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_expm1(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_expm1 ::
-                forall args . Fullfilled "_backward_expm1(ndarray)" args =>
-                  ArgsHMap "_backward_expm1(ndarray)" args -> IO [NDArrayHandle]
-_backward_expm1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_expm1_upd ::
-                    forall args . Fullfilled "_backward_expm1(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_expm1(ndarray)" args -> IO ()
-_backward_expm1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "gamma(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-gamma ::
-      forall args . Fullfilled "gamma(ndarray)" args =>
-        ArgsHMap "gamma(ndarray)" args -> IO [NDArrayHandle]
-gamma args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-gamma_upd ::
-          forall args . Fullfilled "gamma(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "gamma(ndarray)" args -> IO ()
-gamma_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_gamma(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_gamma ::
-                forall args . Fullfilled "_backward_gamma(ndarray)" args =>
-                  ArgsHMap "_backward_gamma(ndarray)" args -> IO [NDArrayHandle]
-_backward_gamma args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_gamma_upd ::
-                    forall args . Fullfilled "_backward_gamma(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_gamma(ndarray)" args -> IO ()
-_backward_gamma_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "gammaln(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-gammaln ::
-        forall args . Fullfilled "gammaln(ndarray)" args =>
-          ArgsHMap "gammaln(ndarray)" args -> IO [NDArrayHandle]
-gammaln args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-gammaln_upd ::
-            forall args . Fullfilled "gammaln(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "gammaln(ndarray)" args -> IO ()
-gammaln_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_gammaln(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_gammaln ::
-                  forall args . Fullfilled "_backward_gammaln(ndarray)" args =>
-                    ArgsHMap "_backward_gammaln(ndarray)" args -> IO [NDArrayHandle]
-_backward_gammaln args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_gammaln_upd ::
-                      forall args . Fullfilled "_backward_gammaln(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_gammaln(ndarray)" args -> IO ()
-_backward_gammaln_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sum(ndarray)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-sum ::
-    forall args . Fullfilled "sum(ndarray)" args =>
-      ArgsHMap "sum(ndarray)" args -> IO [NDArrayHandle]
-sum args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sum_upd ::
-        forall args . Fullfilled "sum(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "sum(ndarray)" args -> IO ()
-sum_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sum(ndarray)" = '[]
-
-_backward_sum ::
-              forall args . Fullfilled "_backward_sum(ndarray)" args =>
-                ArgsHMap "_backward_sum(ndarray)" args -> IO [NDArrayHandle]
-_backward_sum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sum_upd ::
-                  forall args . Fullfilled "_backward_sum(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_sum(ndarray)" args -> IO ()
-_backward_sum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "mean(ndarray)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-mean ::
-     forall args . Fullfilled "mean(ndarray)" args =>
-       ArgsHMap "mean(ndarray)" args -> IO [NDArrayHandle]
-mean args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-mean_upd ::
-         forall args . Fullfilled "mean(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "mean(ndarray)" args -> IO ()
-mean_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mean(ndarray)" = '[]
-
-_backward_mean ::
-               forall args . Fullfilled "_backward_mean(ndarray)" args =>
-                 ArgsHMap "_backward_mean(ndarray)" args -> IO [NDArrayHandle]
-_backward_mean args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mean_upd ::
-                   forall args . Fullfilled "_backward_mean(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_mean(ndarray)" args -> IO ()
-_backward_mean_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "prod(ndarray)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-prod ::
-     forall args . Fullfilled "prod(ndarray)" args =>
-       ArgsHMap "prod(ndarray)" args -> IO [NDArrayHandle]
-prod args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-prod_upd ::
-         forall args . Fullfilled "prod(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "prod(ndarray)" args -> IO ()
-prod_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_prod(ndarray)" = '[]
-
-_backward_prod ::
-               forall args . Fullfilled "_backward_prod(ndarray)" args =>
-                 ArgsHMap "_backward_prod(ndarray)" args -> IO [NDArrayHandle]
-_backward_prod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_prod_upd ::
-                   forall args . Fullfilled "_backward_prod(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_prod(ndarray)" args -> IO ()
-_backward_prod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "nansum(ndarray)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-nansum ::
-       forall args . Fullfilled "nansum(ndarray)" args =>
-         ArgsHMap "nansum(ndarray)" args -> IO [NDArrayHandle]
-nansum args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-nansum_upd ::
-           forall args . Fullfilled "nansum(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "nansum(ndarray)" args -> IO ()
-nansum_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_nansum(ndarray)" = '[]
-
-_backward_nansum ::
-                 forall args . Fullfilled "_backward_nansum(ndarray)" args =>
-                   ArgsHMap "_backward_nansum(ndarray)" args -> IO [NDArrayHandle]
-_backward_nansum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_nansum_upd ::
-                     forall args . Fullfilled "_backward_nansum(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_nansum(ndarray)" args -> IO ()
-_backward_nansum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "nanprod(ndarray)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-nanprod ::
-        forall args . Fullfilled "nanprod(ndarray)" args =>
-          ArgsHMap "nanprod(ndarray)" args -> IO [NDArrayHandle]
-nanprod args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-nanprod_upd ::
-            forall args . Fullfilled "nanprod(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "nanprod(ndarray)" args -> IO ()
-nanprod_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_nanprod(ndarray)" = '[]
-
-_backward_nanprod ::
-                  forall args . Fullfilled "_backward_nanprod(ndarray)" args =>
-                    ArgsHMap "_backward_nanprod(ndarray)" args -> IO [NDArrayHandle]
-_backward_nanprod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_nanprod_upd ::
-                      forall args . Fullfilled "_backward_nanprod(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_nanprod(ndarray)" args -> IO ()
-_backward_nanprod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "max(ndarray)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-max ::
-    forall args . Fullfilled "max(ndarray)" args =>
-      ArgsHMap "max(ndarray)" args -> IO [NDArrayHandle]
-max args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-max_upd ::
-        forall args . Fullfilled "max(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "max(ndarray)" args -> IO ()
-max_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_max(ndarray)" = '[]
-
-_backward_max ::
-              forall args . Fullfilled "_backward_max(ndarray)" args =>
-                ArgsHMap "_backward_max(ndarray)" args -> IO [NDArrayHandle]
-_backward_max args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_max_upd ::
-                  forall args . Fullfilled "_backward_max(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_max(ndarray)" args -> IO ()
-_backward_max_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "min(ndarray)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-min ::
-    forall args . Fullfilled "min(ndarray)" args =>
-      ArgsHMap "min(ndarray)" args -> IO [NDArrayHandle]
-min args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-min_upd ::
-        forall args . Fullfilled "min(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "min(ndarray)" args -> IO ()
-min_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_min(ndarray)" = '[]
-
-_backward_min ::
-              forall args . Fullfilled "_backward_min(ndarray)" args =>
-                ArgsHMap "_backward_min(ndarray)" args -> IO [NDArrayHandle]
-_backward_min args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_min_upd ::
-                  forall args . Fullfilled "_backward_min(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_min(ndarray)" args -> IO ()
-_backward_min_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_axis(ndarray)" =
-     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-broadcast_axis ::
-               forall args . Fullfilled "broadcast_axis(ndarray)" args =>
-                 ArgsHMap "broadcast_axis(ndarray)" args -> IO [NDArrayHandle]
-broadcast_axis args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_axis_upd ::
-                   forall args . Fullfilled "broadcast_axis(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "broadcast_axis(ndarray)" args -> IO ()
-broadcast_axis_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_to(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-broadcast_to ::
-             forall args . Fullfilled "broadcast_to(ndarray)" args =>
-               ArgsHMap "broadcast_to(ndarray)" args -> IO [NDArrayHandle]
-broadcast_to args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_to"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_to_upd ::
-                 forall args . Fullfilled "broadcast_to(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "broadcast_to(ndarray)" args -> IO ()
-broadcast_to_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_to"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_broadcast_backward(ndarray)" = '[]
-
-_broadcast_backward ::
-                    forall args . Fullfilled "_broadcast_backward(ndarray)" args =>
-                      ArgsHMap "_broadcast_backward(ndarray)" args -> IO [NDArrayHandle]
-_broadcast_backward args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_broadcast_backward"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_broadcast_backward_upd ::
-                        forall args . Fullfilled "_broadcast_backward(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_broadcast_backward(ndarray)" args -> IO ()
-_broadcast_backward_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_broadcast_backward"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "norm(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-norm ::
-     forall args . Fullfilled "norm(ndarray)" args =>
-       ArgsHMap "norm(ndarray)" args -> IO [NDArrayHandle]
-norm args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "norm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-norm_upd ::
-         forall args . Fullfilled "norm(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "norm(ndarray)" args -> IO ()
-norm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "norm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_add(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_add ::
-             forall args . Fullfilled "elemwise_add(ndarray)" args =>
-               ArgsHMap "elemwise_add(ndarray)" args -> IO [NDArrayHandle]
-elemwise_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_add_upd ::
-                 forall args . Fullfilled "elemwise_add(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_add(ndarray)" args -> IO ()
-elemwise_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_grad_add(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_grad_add ::
-          forall args . Fullfilled "_grad_add(ndarray)" args =>
-            ArgsHMap "_grad_add(ndarray)" args -> IO [NDArrayHandle]
-_grad_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_grad_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_grad_add_upd ::
-              forall args . Fullfilled "_grad_add(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_grad_add(ndarray)" args -> IO ()
-_grad_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_grad_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_add(ndarray)" = '[]
-
-_backward_add ::
-              forall args . Fullfilled "_backward_add(ndarray)" args =>
-                ArgsHMap "_backward_add(ndarray)" args -> IO [NDArrayHandle]
-_backward_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_add_upd ::
-                  forall args . Fullfilled "_backward_add(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_add(ndarray)" args -> IO ()
-_backward_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_sub(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_sub ::
-             forall args . Fullfilled "elemwise_sub(ndarray)" args =>
-               ArgsHMap "elemwise_sub(ndarray)" args -> IO [NDArrayHandle]
-elemwise_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_sub_upd ::
-                 forall args . Fullfilled "elemwise_sub(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_sub(ndarray)" args -> IO ()
-elemwise_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sub(ndarray)" = '[]
-
-_backward_sub ::
-              forall args . Fullfilled "_backward_sub(ndarray)" args =>
-                ArgsHMap "_backward_sub(ndarray)" args -> IO [NDArrayHandle]
-_backward_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sub_upd ::
-                  forall args . Fullfilled "_backward_sub(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_sub(ndarray)" args -> IO ()
-_backward_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_mul(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_mul ::
-             forall args . Fullfilled "elemwise_mul(ndarray)" args =>
-               ArgsHMap "elemwise_mul(ndarray)" args -> IO [NDArrayHandle]
-elemwise_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_mul_upd ::
-                 forall args . Fullfilled "elemwise_mul(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_mul(ndarray)" args -> IO ()
-elemwise_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mul(ndarray)" = '[]
-
-_backward_mul ::
-              forall args . Fullfilled "_backward_mul(ndarray)" args =>
-                ArgsHMap "_backward_mul(ndarray)" args -> IO [NDArrayHandle]
-_backward_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mul_upd ::
-                  forall args . Fullfilled "_backward_mul(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_mul(ndarray)" args -> IO ()
-_backward_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_div(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_div ::
-             forall args . Fullfilled "elemwise_div(ndarray)" args =>
-               ArgsHMap "elemwise_div(ndarray)" args -> IO [NDArrayHandle]
-elemwise_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_div_upd ::
-                 forall args . Fullfilled "elemwise_div(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_div(ndarray)" args -> IO ()
-elemwise_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_div(ndarray)" = '[]
-
-_backward_div ::
-              forall args . Fullfilled "_backward_div(ndarray)" args =>
-                ArgsHMap "_backward_div(ndarray)" args -> IO [NDArrayHandle]
-_backward_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_div_upd ::
-                  forall args . Fullfilled "_backward_div(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_div(ndarray)" args -> IO ()
-_backward_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_mod(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_mod ::
-     forall args . Fullfilled "_mod(ndarray)" args =>
-       ArgsHMap "_mod(ndarray)" args -> IO [NDArrayHandle]
-_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_mod_upd ::
-         forall args . Fullfilled "_mod(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_mod(ndarray)" args -> IO ()
-_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mod(ndarray)" = '[]
-
-_backward_mod ::
-              forall args . Fullfilled "_backward_mod(ndarray)" args =>
-                ArgsHMap "_backward_mod(ndarray)" args -> IO [NDArrayHandle]
-_backward_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mod_upd ::
-                  forall args . Fullfilled "_backward_mod(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_mod(ndarray)" args -> IO ()
-_backward_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_plus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_plus_scalar ::
-             forall args . Fullfilled "_plus_scalar(ndarray)" args =>
-               ArgsHMap "_plus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_plus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_plus_scalar_upd ::
-                 forall args . Fullfilled "_plus_scalar(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_plus_scalar(ndarray)" args -> IO ()
-_plus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_minus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_minus_scalar ::
-              forall args . Fullfilled "_minus_scalar(ndarray)" args =>
-                ArgsHMap "_minus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_minus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_minus_scalar_upd ::
-                  forall args . Fullfilled "_minus_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_minus_scalar(ndarray)" args -> IO ()
-_minus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rminus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rminus_scalar ::
-               forall args . Fullfilled "_rminus_scalar(ndarray)" args =>
-                 ArgsHMap "_rminus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rminus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rminus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rminus_scalar_upd ::
-                   forall args . Fullfilled "_rminus_scalar(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_rminus_scalar(ndarray)" args -> IO ()
-_rminus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rminus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_mul_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_mul_scalar ::
-            forall args . Fullfilled "_mul_scalar(ndarray)" args =>
-              ArgsHMap "_mul_scalar(ndarray)" args -> IO [NDArrayHandle]
-_mul_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_mul_scalar_upd ::
-                forall args . Fullfilled "_mul_scalar(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_mul_scalar(ndarray)" args -> IO ()
-_mul_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mul_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_backward_mul_scalar ::
-                     forall args . Fullfilled "_backward_mul_scalar(ndarray)" args =>
-                       ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO [NDArrayHandle]
-_backward_mul_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mul_scalar_upd ::
-                         forall args . Fullfilled "_backward_mul_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO ()
-_backward_mul_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_div_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_div_scalar ::
-            forall args . Fullfilled "_div_scalar(ndarray)" args =>
-              ArgsHMap "_div_scalar(ndarray)" args -> IO [NDArrayHandle]
-_div_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_div_scalar_upd ::
-                forall args . Fullfilled "_div_scalar(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_div_scalar(ndarray)" args -> IO ()
-_div_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_div_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_backward_div_scalar ::
-                     forall args . Fullfilled "_backward_div_scalar(ndarray)" args =>
-                       ArgsHMap "_backward_div_scalar(ndarray)" args -> IO [NDArrayHandle]
-_backward_div_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_div_scalar_upd ::
-                         forall args . Fullfilled "_backward_div_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_div_scalar(ndarray)" args -> IO ()
-_backward_div_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rdiv_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rdiv_scalar ::
-             forall args . Fullfilled "_rdiv_scalar(ndarray)" args =>
-               ArgsHMap "_rdiv_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rdiv_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rdiv_scalar_upd ::
-                 forall args . Fullfilled "_rdiv_scalar(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_rdiv_scalar(ndarray)" args -> IO ()
-_rdiv_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rdiv_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rdiv_scalar ::
-                      forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args =>
-                        ArgsHMap "_backward_rdiv_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_rdiv_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rdiv_scalar_upd ::
-                          forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> IO ()
-_backward_rdiv_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_mod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_mod_scalar ::
-            forall args . Fullfilled "_mod_scalar(ndarray)" args =>
-              ArgsHMap "_mod_scalar(ndarray)" args -> IO [NDArrayHandle]
-_mod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_mod_scalar_upd ::
-                forall args . Fullfilled "_mod_scalar(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_mod_scalar(ndarray)" args -> IO ()
-_mod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_mod_scalar ::
-                     forall args . Fullfilled "_backward_mod_scalar(ndarray)" args =>
-                       ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO [NDArrayHandle]
-_backward_mod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mod_scalar_upd ::
-                         forall args . Fullfilled "_backward_mod_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO ()
-_backward_mod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rmod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rmod_scalar ::
-             forall args . Fullfilled "_rmod_scalar(ndarray)" args =>
-               ArgsHMap "_rmod_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rmod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rmod_scalar_upd ::
-                 forall args . Fullfilled "_rmod_scalar(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_rmod_scalar(ndarray)" args -> IO ()
-_rmod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rmod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rmod_scalar ::
-                      forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args =>
-                        ArgsHMap "_backward_rmod_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_rmod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rmod_scalar_upd ::
-                          forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_rmod_scalar(ndarray)" args -> IO ()
-_backward_rmod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_elemwise_div(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_scatter_elemwise_div ::
-                      forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args =>
-                        ArgsHMap "_scatter_elemwise_div(ndarray)" args ->
-                          IO [NDArrayHandle]
-_scatter_elemwise_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_elemwise_div_upd ::
-                          forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_scatter_elemwise_div(ndarray)" args -> IO ()
-_scatter_elemwise_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_plus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_scatter_plus_scalar ::
-                     forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args =>
-                       ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_scatter_plus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_plus_scalar_upd ::
-                         forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO ()
-_scatter_plus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_minus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_scatter_minus_scalar ::
-                      forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args =>
-                        ArgsHMap "_scatter_minus_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_scatter_minus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_minus_scalar_upd ::
-                          forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_scatter_minus_scalar(ndarray)" args -> IO ()
-_scatter_minus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Embedding(ndarray)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle)]
-
-_Embedding ::
-           forall args . Fullfilled "_Embedding(ndarray)" args =>
-             ArgsHMap "_Embedding(ndarray)" args -> IO [NDArrayHandle]
-_Embedding args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Embedding_upd ::
-               forall args . Fullfilled "_Embedding(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_Embedding(ndarray)" args -> IO ()
-_Embedding_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_SparseEmbedding(ndarray)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle)]
-
-_contrib_SparseEmbedding ::
-                         forall args .
-                           Fullfilled "_contrib_SparseEmbedding(ndarray)" args =>
-                           ArgsHMap "_contrib_SparseEmbedding(ndarray)" args ->
-                             IO [NDArrayHandle]
-_contrib_SparseEmbedding args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_SparseEmbedding_upd ::
-                             forall args .
-                               Fullfilled "_contrib_SparseEmbedding(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> IO ()
-_contrib_SparseEmbedding_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Embedding(ndarray)" = '[]
-
-_backward_Embedding ::
-                    forall args . Fullfilled "_backward_Embedding(ndarray)" args =>
-                      ArgsHMap "_backward_Embedding(ndarray)" args -> IO [NDArrayHandle]
-_backward_Embedding args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Embedding_upd ::
-                        forall args . Fullfilled "_backward_Embedding(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_Embedding(ndarray)" args -> IO ()
-_backward_Embedding_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SparseEmbedding(ndarray)" =
-     '[]
-
-_backward_SparseEmbedding ::
-                          forall args .
-                            Fullfilled "_backward_SparseEmbedding(ndarray)" args =>
-                            ArgsHMap "_backward_SparseEmbedding(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_SparseEmbedding args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SparseEmbedding_upd ::
-                              forall args .
-                                Fullfilled "_backward_SparseEmbedding(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> IO ()
-_backward_SparseEmbedding_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "take(ndarray)" =
-     '[ '("axis", AttrOpt Int),
-        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),
-        '("a", AttrOpt NDArrayHandle), '("indices", AttrOpt NDArrayHandle)]
-
-take ::
-     forall args . Fullfilled "take(ndarray)" args =>
-       ArgsHMap "take(ndarray)" args -> IO [NDArrayHandle]
-take args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-take_upd ::
-         forall args . Fullfilled "take(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "take(ndarray)" args -> IO ()
-take_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_take(ndarray)" = '[]
-
-_backward_take ::
-               forall args . Fullfilled "_backward_take(ndarray)" args =>
-                 ArgsHMap "_backward_take(ndarray)" args -> IO [NDArrayHandle]
-_backward_take args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_take_upd ::
-                   forall args . Fullfilled "_backward_take(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_take(ndarray)" args -> IO ()
-_backward_take_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "batch_take(ndarray)" =
-     '[ '("a", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-batch_take ::
-           forall args . Fullfilled "batch_take(ndarray)" args =>
-             ArgsHMap "batch_take(ndarray)" args -> IO [NDArrayHandle]
-batch_take args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-batch_take_upd ::
-               forall args . Fullfilled "batch_take(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "batch_take(ndarray)" args -> IO ()
-batch_take_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "one_hot(ndarray)" =
-     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),
-        '("off_value", AttrOpt Double),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("indices", AttrOpt NDArrayHandle)]
-
-one_hot ::
-        forall args . Fullfilled "one_hot(ndarray)" args =>
-          ArgsHMap "one_hot(ndarray)" args -> IO [NDArrayHandle]
-one_hot args
-  = let scalarArgs
-          = catMaybes
-              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),
-               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),
-               ("off_value",) . showValue <$>
-                 (args !? #off_value :: Maybe Double),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "one_hot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-one_hot_upd ::
-            forall args . Fullfilled "one_hot(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "one_hot(ndarray)" args -> IO ()
-one_hot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),
-               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),
-               ("off_value",) . showValue <$>
-                 (args !? #off_value :: Maybe Double),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "one_hot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "gather_nd(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-gather_nd ::
-          forall args . Fullfilled "gather_nd(ndarray)" args =>
-            ArgsHMap "gather_nd(ndarray)" args -> IO [NDArrayHandle]
-gather_nd args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gather_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-gather_nd_upd ::
-              forall args . Fullfilled "gather_nd(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "gather_nd(ndarray)" args -> IO ()
-gather_nd_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gather_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "scatter_nd(ndarray)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-scatter_nd ::
-           forall args . Fullfilled "scatter_nd(ndarray)" args =>
-             ArgsHMap "scatter_nd(ndarray)" args -> IO [NDArrayHandle]
-scatter_nd args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "scatter_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-scatter_nd_upd ::
-               forall args . Fullfilled "scatter_nd(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "scatter_nd(ndarray)" args -> IO ()
-scatter_nd_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "scatter_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_set_nd(ndarray)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-_scatter_set_nd ::
-                forall args . Fullfilled "_scatter_set_nd(ndarray)" args =>
-                  ArgsHMap "_scatter_set_nd(ndarray)" args -> IO [NDArrayHandle]
-_scatter_set_nd args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_set_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_set_nd_upd ::
-                    forall args . Fullfilled "_scatter_set_nd(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_scatter_set_nd(ndarray)" args -> IO ()
-_scatter_set_nd_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_set_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_equal ::
-                forall args . Fullfilled "broadcast_equal(ndarray)" args =>
-                  ArgsHMap "broadcast_equal(ndarray)" args -> IO [NDArrayHandle]
-broadcast_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_equal_upd ::
-                    forall args . Fullfilled "broadcast_equal(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "broadcast_equal(ndarray)" args -> IO ()
-broadcast_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_not_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_not_equal ::
-                    forall args . Fullfilled "broadcast_not_equal(ndarray)" args =>
-                      ArgsHMap "broadcast_not_equal(ndarray)" args -> IO [NDArrayHandle]
-broadcast_not_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_not_equal_upd ::
-                        forall args . Fullfilled "broadcast_not_equal(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "broadcast_not_equal(ndarray)" args -> IO ()
-broadcast_not_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_greater(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_greater ::
-                  forall args . Fullfilled "broadcast_greater(ndarray)" args =>
-                    ArgsHMap "broadcast_greater(ndarray)" args -> IO [NDArrayHandle]
-broadcast_greater args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_greater_upd ::
-                      forall args . Fullfilled "broadcast_greater(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "broadcast_greater(ndarray)" args -> IO ()
-broadcast_greater_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_greater_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_greater_equal ::
-                        forall args . Fullfilled "broadcast_greater_equal(ndarray)" args =>
-                          ArgsHMap "broadcast_greater_equal(ndarray)" args ->
-                            IO [NDArrayHandle]
-broadcast_greater_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_greater_equal_upd ::
-                            forall args . Fullfilled "broadcast_greater_equal(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "broadcast_greater_equal(ndarray)" args -> IO ()
-broadcast_greater_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_lesser(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_lesser ::
-                 forall args . Fullfilled "broadcast_lesser(ndarray)" args =>
-                   ArgsHMap "broadcast_lesser(ndarray)" args -> IO [NDArrayHandle]
-broadcast_lesser args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_lesser_upd ::
-                     forall args . Fullfilled "broadcast_lesser(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "broadcast_lesser(ndarray)" args -> IO ()
-broadcast_lesser_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_lesser_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_lesser_equal ::
-                       forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args =>
-                         ArgsHMap "broadcast_lesser_equal(ndarray)" args ->
-                           IO [NDArrayHandle]
-broadcast_lesser_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_lesser_equal_upd ::
-                           forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "broadcast_lesser_equal(ndarray)" args -> IO ()
-broadcast_lesser_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argmax(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-argmax ::
-       forall args . Fullfilled "argmax(ndarray)" args =>
-         ArgsHMap "argmax(ndarray)" args -> IO [NDArrayHandle]
-argmax args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argmax_upd ::
-           forall args . Fullfilled "argmax(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "argmax(ndarray)" args -> IO ()
-argmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argmin(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-argmin ::
-       forall args . Fullfilled "argmin(ndarray)" args =>
-         ArgsHMap "argmin(ndarray)" args -> IO [NDArrayHandle]
-argmin args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argmin_upd ::
-           forall args . Fullfilled "argmin(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "argmin(ndarray)" args -> IO ()
-argmin_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argmax_channel(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-argmax_channel ::
-               forall args . Fullfilled "argmax_channel(ndarray)" args =>
-                 ArgsHMap "argmax_channel(ndarray)" args -> IO [NDArrayHandle]
-argmax_channel args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax_channel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argmax_channel_upd ::
-                   forall args . Fullfilled "argmax_channel(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "argmax_channel(ndarray)" args -> IO ()
-argmax_channel_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax_channel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "pick(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle),
-        '("index", AttrOpt NDArrayHandle)]
-
-pick ::
-     forall args . Fullfilled "pick(ndarray)" args =>
-       ArgsHMap "pick(ndarray)" args -> IO [NDArrayHandle]
-pick args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-pick_upd ::
-         forall args . Fullfilled "pick(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "pick(ndarray)" args -> IO ()
-pick_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_pick(ndarray)" = '[]
-
-_backward_pick ::
-               forall args . Fullfilled "_backward_pick(ndarray)" args =>
-                 ArgsHMap "_backward_pick(ndarray)" args -> IO [NDArrayHandle]
-_backward_pick args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_pick_upd ::
-                   forall args . Fullfilled "_backward_pick(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_pick(ndarray)" args -> IO ()
-_backward_pick_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sparse_retain(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-_sparse_retain ::
-               forall args . Fullfilled "_sparse_retain(ndarray)" args =>
-                 ArgsHMap "_sparse_retain(ndarray)" args -> IO [NDArrayHandle]
-_sparse_retain args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sparse_retain_upd ::
-                   forall args . Fullfilled "_sparse_retain(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_sparse_retain(ndarray)" args -> IO ()
-_sparse_retain_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sparse_retain(ndarray)" =
-     '[]
-
-_backward_sparse_retain ::
-                        forall args . Fullfilled "_backward_sparse_retain(ndarray)" args =>
-                          ArgsHMap "_backward_sparse_retain(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_sparse_retain args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sparse_retain_upd ::
-                            forall args . Fullfilled "_backward_sparse_retain(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_sparse_retain(ndarray)" args -> IO ()
-_backward_sparse_retain_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_where(ndarray)" =
-     '[ '("condition", AttrOpt NDArrayHandle),
-        '("x", AttrOpt NDArrayHandle), '("y", AttrOpt NDArrayHandle)]
-
-_where ::
-       forall args . Fullfilled "_where(ndarray)" args =>
-         ArgsHMap "_where(ndarray)" args -> IO [NDArrayHandle]
-_where args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle),
-               ("x",) <$> (args !? #x :: Maybe NDArrayHandle),
-               ("y",) <$> (args !? #y :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_where_upd ::
-           forall args . Fullfilled "_where(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_where(ndarray)" args -> IO ()
-_where_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle),
-               ("x",) <$> (args !? #x :: Maybe NDArrayHandle),
-               ("y",) <$> (args !? #y :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_where(ndarray)" = '[]
-
-_backward_where ::
-                forall args . Fullfilled "_backward_where(ndarray)" args =>
-                  ArgsHMap "_backward_where(ndarray)" args -> IO [NDArrayHandle]
-_backward_where args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_where_upd ::
-                    forall args . Fullfilled "_backward_where(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_where(ndarray)" args -> IO ()
-_backward_where_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_maximum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_maximum_scalar ::
-                forall args . Fullfilled "_maximum_scalar(ndarray)" args =>
-                  ArgsHMap "_maximum_scalar(ndarray)" args -> IO [NDArrayHandle]
-_maximum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_maximum_scalar_upd ::
-                    forall args . Fullfilled "_maximum_scalar(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_maximum_scalar(ndarray)" args -> IO ()
-_maximum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_maximum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_maximum_scalar ::
-                         forall args .
-                           Fullfilled "_backward_maximum_scalar(ndarray)" args =>
-                           ArgsHMap "_backward_maximum_scalar(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_maximum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_maximum_scalar_upd ::
-                             forall args .
-                               Fullfilled "_backward_maximum_scalar(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_maximum_scalar(ndarray)" args -> IO ()
-_backward_maximum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_minimum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_minimum_scalar ::
-                forall args . Fullfilled "_minimum_scalar(ndarray)" args =>
-                  ArgsHMap "_minimum_scalar(ndarray)" args -> IO [NDArrayHandle]
-_minimum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_minimum_scalar_upd ::
-                    forall args . Fullfilled "_minimum_scalar(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_minimum_scalar(ndarray)" args -> IO ()
-_minimum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_minimum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_minimum_scalar ::
-                         forall args .
-                           Fullfilled "_backward_minimum_scalar(ndarray)" args =>
-                           ArgsHMap "_backward_minimum_scalar(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_minimum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_minimum_scalar_upd ::
-                             forall args .
-                               Fullfilled "_backward_minimum_scalar(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_minimum_scalar(ndarray)" args -> IO ()
-_backward_minimum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_power_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_power_scalar ::
-              forall args . Fullfilled "_power_scalar(ndarray)" args =>
-                ArgsHMap "_power_scalar(ndarray)" args -> IO [NDArrayHandle]
-_power_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_power_scalar_upd ::
-                  forall args . Fullfilled "_power_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_power_scalar(ndarray)" args -> IO ()
-_power_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_power_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_power_scalar ::
-                       forall args . Fullfilled "_backward_power_scalar(ndarray)" args =>
-                         ArgsHMap "_backward_power_scalar(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_power_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_power_scalar_upd ::
-                           forall args . Fullfilled "_backward_power_scalar(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_power_scalar(ndarray)" args -> IO ()
-_backward_power_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rpower_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rpower_scalar ::
-               forall args . Fullfilled "_rpower_scalar(ndarray)" args =>
-                 ArgsHMap "_rpower_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rpower_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rpower_scalar_upd ::
-                   forall args . Fullfilled "_rpower_scalar(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_rpower_scalar(ndarray)" args -> IO ()
-_rpower_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rpower_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rpower_scalar ::
-                        forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args =>
-                          ArgsHMap "_backward_rpower_scalar(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_rpower_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rpower_scalar_upd ::
-                            forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_rpower_scalar(ndarray)" args -> IO ()
-_backward_rpower_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_hypot_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_hypot_scalar ::
-              forall args . Fullfilled "_hypot_scalar(ndarray)" args =>
-                ArgsHMap "_hypot_scalar(ndarray)" args -> IO [NDArrayHandle]
-_hypot_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_hypot_scalar_upd ::
-                  forall args . Fullfilled "_hypot_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_hypot_scalar(ndarray)" args -> IO ()
-_hypot_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_hypot_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_hypot_scalar ::
-                       forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args =>
-                         ArgsHMap "_backward_hypot_scalar(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_hypot_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_hypot_scalar_upd ::
-                           forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_hypot_scalar(ndarray)" args -> IO ()
-_backward_hypot_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "smooth_l1(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-smooth_l1 ::
-          forall args . Fullfilled "smooth_l1(ndarray)" args =>
-            ArgsHMap "smooth_l1(ndarray)" args -> IO [NDArrayHandle]
-smooth_l1 args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-smooth_l1_upd ::
-              forall args . Fullfilled "smooth_l1(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "smooth_l1(ndarray)" args -> IO ()
-smooth_l1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_smooth_l1(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_smooth_l1 ::
-                    forall args . Fullfilled "_backward_smooth_l1(ndarray)" args =>
-                      ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO [NDArrayHandle]
-_backward_smooth_l1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_smooth_l1_upd ::
-                        forall args . Fullfilled "_backward_smooth_l1(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO ()
-_backward_smooth_l1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "topk(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),
-        '("ret_typ",
-          AttrOpt (EnumType '["both", "indices", "mask", "value"])),
-        '("is_ascend", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-topk ::
-     forall args . Fullfilled "topk(ndarray)" args =>
-       ArgsHMap "topk(ndarray)" args -> IO [NDArrayHandle]
-topk args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ret_typ",) . showValue <$>
-                 (args !? #ret_typ ::
-                    Maybe (EnumType '["both", "indices", "mask", "value"])),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-topk_upd ::
-         forall args . Fullfilled "topk(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "topk(ndarray)" args -> IO ()
-topk_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ret_typ",) . showValue <$>
-                 (args !? #ret_typ ::
-                    Maybe (EnumType '["both", "indices", "mask", "value"])),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_topk(ndarray)" = '[]
-
-_backward_topk ::
-               forall args . Fullfilled "_backward_topk(ndarray)" args =>
-                 ArgsHMap "_backward_topk(ndarray)" args -> IO [NDArrayHandle]
-_backward_topk args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_topk_upd ::
-                   forall args . Fullfilled "_backward_topk(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_topk(ndarray)" args -> IO ()
-_backward_topk_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sort(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-sort ::
-     forall args . Fullfilled "sort(ndarray)" args =>
-       ArgsHMap "sort(ndarray)" args -> IO [NDArrayHandle]
-sort args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sort_upd ::
-         forall args . Fullfilled "sort(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sort(ndarray)" args -> IO ()
-sort_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argsort(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-argsort ::
-        forall args . Fullfilled "argsort(ndarray)" args =>
-          ArgsHMap "argsort(ndarray)" args -> IO [NDArrayHandle]
-argsort args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argsort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argsort_upd ::
-            forall args . Fullfilled "argsort(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "argsort(ndarray)" args -> IO ()
-argsort_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argsort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Reshape(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),
-        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Reshape ::
-         forall args . Fullfilled "_Reshape(ndarray)" args =>
-           ArgsHMap "_Reshape(ndarray)" args -> IO [NDArrayHandle]
-_Reshape args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("keep_highest",) . showValue <$>
-                 (args !? #keep_highest :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Reshape"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Reshape_upd ::
-             forall args . Fullfilled "_Reshape(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Reshape(ndarray)" args -> IO ()
-_Reshape_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("keep_highest",) . showValue <$>
-                 (args !? #keep_highest :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Reshape"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Flatten(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_Flatten ::
-         forall args . Fullfilled "_Flatten(ndarray)" args =>
-           ArgsHMap "_Flatten(ndarray)" args -> IO [NDArrayHandle]
-_Flatten args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Flatten"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Flatten_upd ::
-             forall args . Fullfilled "_Flatten(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Flatten(ndarray)" args -> IO ()
-_Flatten_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Flatten"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "transpose(ndarray)" =
-     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-transpose ::
-          forall args . Fullfilled "transpose(ndarray)" args =>
-            ArgsHMap "transpose(ndarray)" args -> IO [NDArrayHandle]
-transpose args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "transpose"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-transpose_upd ::
-              forall args . Fullfilled "transpose(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "transpose(ndarray)" args -> IO ()
-transpose_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "transpose"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "expand_dims(ndarray)" =
-     '[ '("axis", AttrReq Int), '("data", AttrOpt NDArrayHandle)]
-
-expand_dims ::
-            forall args . Fullfilled "expand_dims(ndarray)" args =>
-              ArgsHMap "expand_dims(ndarray)" args -> IO [NDArrayHandle]
-expand_dims args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expand_dims"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-expand_dims_upd ::
-                forall args . Fullfilled "expand_dims(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "expand_dims(ndarray)" args -> IO ()
-expand_dims_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expand_dims"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "slice(ndarray)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-slice ::
-      forall args . Fullfilled "slice(ndarray)" args =>
-        ArgsHMap "slice(ndarray)" args -> IO [NDArrayHandle]
-slice args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-slice_upd ::
-          forall args . Fullfilled "slice(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "slice(ndarray)" args -> IO ()
-slice_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_slice(ndarray)" = '[]
-
-_backward_slice ::
-                forall args . Fullfilled "_backward_slice(ndarray)" args =>
-                  ArgsHMap "_backward_slice(ndarray)" args -> IO [NDArrayHandle]
-_backward_slice args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_slice_upd ::
-                    forall args . Fullfilled "_backward_slice(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_slice(ndarray)" args -> IO ()
-_backward_slice_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_slice_assign(ndarray)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_slice_assign ::
-              forall args . Fullfilled "_slice_assign(ndarray)" args =>
-                ArgsHMap "_slice_assign(ndarray)" args -> IO [NDArrayHandle]
-_slice_assign args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_slice_assign_upd ::
-                  forall args . Fullfilled "_slice_assign(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_slice_assign(ndarray)" args -> IO ()
-_slice_assign_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_slice_assign_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("begin", AttrReq [Int]),
-        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_slice_assign_scalar ::
-                     forall args . Fullfilled "_slice_assign_scalar(ndarray)" args =>
-                       ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO [NDArrayHandle]
-_slice_assign_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_slice_assign_scalar_upd ::
-                         forall args . Fullfilled "_slice_assign_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO ()
-_slice_assign_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "slice_axis(ndarray)" =
-     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),
-        '("end", AttrReq (Maybe Int)), '("data", AttrOpt NDArrayHandle)]
-
-slice_axis ::
-           forall args . Fullfilled "slice_axis(ndarray)" args =>
-             ArgsHMap "slice_axis(ndarray)" args -> IO [NDArrayHandle]
-slice_axis args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),
-               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-slice_axis_upd ::
-               forall args . Fullfilled "slice_axis(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "slice_axis(ndarray)" args -> IO ()
-slice_axis_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),
-               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_slice_axis(ndarray)" = '[]
-
-_backward_slice_axis ::
-                     forall args . Fullfilled "_backward_slice_axis(ndarray)" args =>
-                       ArgsHMap "_backward_slice_axis(ndarray)" args -> IO [NDArrayHandle]
-_backward_slice_axis args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_slice_axis_upd ::
-                         forall args . Fullfilled "_backward_slice_axis(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_slice_axis(ndarray)" args -> IO ()
-_backward_slice_axis_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "clip(ndarray)" =
-     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-clip ::
-     forall args . Fullfilled "clip(ndarray)" args =>
-       ArgsHMap "clip(ndarray)" args -> IO [NDArrayHandle]
-clip args
-  = let scalarArgs
-          = catMaybes
-              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),
-               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-clip_upd ::
-         forall args . Fullfilled "clip(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "clip(ndarray)" args -> IO ()
-clip_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),
-               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_clip(ndarray)" = '[]
-
-_backward_clip ::
-               forall args . Fullfilled "_backward_clip(ndarray)" args =>
-                 ArgsHMap "_backward_clip(ndarray)" args -> IO [NDArrayHandle]
-_backward_clip args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_clip_upd ::
-                   forall args . Fullfilled "_backward_clip(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_clip(ndarray)" args -> IO ()
-_backward_clip_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "repeat(ndarray)" =
-     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),
-        '("data", AttrOpt NDArrayHandle)]
-
-repeat ::
-       forall args . Fullfilled "repeat(ndarray)" args =>
-         ArgsHMap "repeat(ndarray)" args -> IO [NDArrayHandle]
-repeat args
-  = let scalarArgs
-          = catMaybes
-              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-repeat_upd ::
-           forall args . Fullfilled "repeat(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "repeat(ndarray)" args -> IO ()
-repeat_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_repeat(ndarray)" = '[]
-
-_backward_repeat ::
-                 forall args . Fullfilled "_backward_repeat(ndarray)" args =>
-                   ArgsHMap "_backward_repeat(ndarray)" args -> IO [NDArrayHandle]
-_backward_repeat args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_repeat_upd ::
-                     forall args . Fullfilled "_backward_repeat(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_repeat(ndarray)" args -> IO ()
-_backward_repeat_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "tile(ndarray)" =
-     '[ '("reps", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)]
-
-tile ::
-     forall args . Fullfilled "tile(ndarray)" args =>
-       ArgsHMap "tile(ndarray)" args -> IO [NDArrayHandle]
-tile args
-  = let scalarArgs
-          = catMaybes
-              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-tile_upd ::
-         forall args . Fullfilled "tile(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "tile(ndarray)" args -> IO ()
-tile_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_tile(ndarray)" = '[]
-
-_backward_tile ::
-               forall args . Fullfilled "_backward_tile(ndarray)" args =>
-                 ArgsHMap "_backward_tile(ndarray)" args -> IO [NDArrayHandle]
-_backward_tile args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_tile_upd ::
-                   forall args . Fullfilled "_backward_tile(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_tile(ndarray)" args -> IO ()
-_backward_tile_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "reverse(ndarray)" =
-     '[ '("axis", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)]
-
-reverse ::
-        forall args . Fullfilled "reverse(ndarray)" args =>
-          ArgsHMap "reverse(ndarray)" args -> IO [NDArrayHandle]
-reverse args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-reverse_upd ::
-            forall args . Fullfilled "reverse(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "reverse(ndarray)" args -> IO ()
-reverse_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_reverse(ndarray)" = '[]
-
-_backward_reverse ::
-                  forall args . Fullfilled "_backward_reverse(ndarray)" args =>
-                    ArgsHMap "_backward_reverse(ndarray)" args -> IO [NDArrayHandle]
-_backward_reverse args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_reverse_upd ::
-                      forall args . Fullfilled "_backward_reverse(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_reverse(ndarray)" args -> IO ()
-_backward_reverse_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "stack(ndarray)" =
-     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-stack ::
-      forall args . Fullfilled "stack(ndarray)" args =>
-        ArgsHMap "stack(ndarray)" args -> IO [NDArrayHandle]
-stack args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "stack"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-stack_upd ::
-          forall args . Fullfilled "stack(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "stack(ndarray)" args -> IO ()
-stack_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "stack"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_stack(ndarray)" = '[]
-
-_backward_stack ::
-                forall args . Fullfilled "_backward_stack(ndarray)" args =>
-                  ArgsHMap "_backward_stack(ndarray)" args -> IO [NDArrayHandle]
-_backward_stack args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_stack"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_stack_upd ::
-                    forall args . Fullfilled "_backward_stack(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_stack(ndarray)" args -> IO ()
-_backward_stack_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_stack"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "dot(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-dot ::
-    forall args . Fullfilled "dot(ndarray)" args =>
-      ArgsHMap "dot(ndarray)" args -> IO [NDArrayHandle]
-dot args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-dot_upd ::
-        forall args . Fullfilled "dot(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "dot(ndarray)" args -> IO ()
-dot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_dot(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool)]
-
-_backward_dot ::
-              forall args . Fullfilled "_backward_dot(ndarray)" args =>
-                ArgsHMap "_backward_dot(ndarray)" args -> IO [NDArrayHandle]
-_backward_dot args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_dot_upd ::
-                  forall args . Fullfilled "_backward_dot(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_dot(ndarray)" args -> IO ()
-_backward_dot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "batch_dot(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-batch_dot ::
-          forall args . Fullfilled "batch_dot(ndarray)" args =>
-            ArgsHMap "batch_dot(ndarray)" args -> IO [NDArrayHandle]
-batch_dot args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-batch_dot_upd ::
-              forall args . Fullfilled "batch_dot(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "batch_dot(ndarray)" args -> IO ()
-batch_dot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_batch_dot(ndarray)" = '[]
-
-_backward_batch_dot ::
-                    forall args . Fullfilled "_backward_batch_dot(ndarray)" args =>
-                      ArgsHMap "_backward_batch_dot(ndarray)" args -> IO [NDArrayHandle]
-_backward_batch_dot args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_batch_dot_upd ::
-                        forall args . Fullfilled "_backward_batch_dot(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_batch_dot(ndarray)" args -> IO ()
-_backward_batch_dot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sin(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sin ::
-    forall args . Fullfilled "sin(ndarray)" args =>
-      ArgsHMap "sin(ndarray)" args -> IO [NDArrayHandle]
-sin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sin_upd ::
-        forall args . Fullfilled "sin(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "sin(ndarray)" args -> IO ()
-sin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sin(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sin ::
-              forall args . Fullfilled "_backward_sin(ndarray)" args =>
-                ArgsHMap "_backward_sin(ndarray)" args -> IO [NDArrayHandle]
-_backward_sin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sin_upd ::
-                  forall args . Fullfilled "_backward_sin(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_sin(ndarray)" args -> IO ()
-_backward_sin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cos(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-cos ::
-    forall args . Fullfilled "cos(ndarray)" args =>
-      ArgsHMap "cos(ndarray)" args -> IO [NDArrayHandle]
-cos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cos_upd ::
-        forall args . Fullfilled "cos(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "cos(ndarray)" args -> IO ()
-cos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cos(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_cos ::
-              forall args . Fullfilled "_backward_cos(ndarray)" args =>
-                ArgsHMap "_backward_cos(ndarray)" args -> IO [NDArrayHandle]
-_backward_cos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cos_upd ::
-                  forall args . Fullfilled "_backward_cos(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_cos(ndarray)" args -> IO ()
-_backward_cos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "tan(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-tan ::
-    forall args . Fullfilled "tan(ndarray)" args =>
-      ArgsHMap "tan(ndarray)" args -> IO [NDArrayHandle]
-tan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-tan_upd ::
-        forall args . Fullfilled "tan(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "tan(ndarray)" args -> IO ()
-tan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_tan(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_tan ::
-              forall args . Fullfilled "_backward_tan(ndarray)" args =>
-                ArgsHMap "_backward_tan(ndarray)" args -> IO [NDArrayHandle]
-_backward_tan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_tan_upd ::
-                  forall args . Fullfilled "_backward_tan(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_tan(ndarray)" args -> IO ()
-_backward_tan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arcsin(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arcsin ::
-       forall args . Fullfilled "arcsin(ndarray)" args =>
-         ArgsHMap "arcsin(ndarray)" args -> IO [NDArrayHandle]
-arcsin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arcsin_upd ::
-           forall args . Fullfilled "arcsin(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "arcsin(ndarray)" args -> IO ()
-arcsin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arcsin(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arcsin ::
-                 forall args . Fullfilled "_backward_arcsin(ndarray)" args =>
-                   ArgsHMap "_backward_arcsin(ndarray)" args -> IO [NDArrayHandle]
-_backward_arcsin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arcsin_upd ::
-                     forall args . Fullfilled "_backward_arcsin(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_arcsin(ndarray)" args -> IO ()
-_backward_arcsin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arccos(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arccos ::
-       forall args . Fullfilled "arccos(ndarray)" args =>
-         ArgsHMap "arccos(ndarray)" args -> IO [NDArrayHandle]
-arccos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arccos_upd ::
-           forall args . Fullfilled "arccos(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "arccos(ndarray)" args -> IO ()
-arccos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arccos(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arccos ::
-                 forall args . Fullfilled "_backward_arccos(ndarray)" args =>
-                   ArgsHMap "_backward_arccos(ndarray)" args -> IO [NDArrayHandle]
-_backward_arccos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arccos_upd ::
-                     forall args . Fullfilled "_backward_arccos(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_arccos(ndarray)" args -> IO ()
-_backward_arccos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arctan(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arctan ::
-       forall args . Fullfilled "arctan(ndarray)" args =>
-         ArgsHMap "arctan(ndarray)" args -> IO [NDArrayHandle]
-arctan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arctan_upd ::
-           forall args . Fullfilled "arctan(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "arctan(ndarray)" args -> IO ()
-arctan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arctan(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arctan ::
-                 forall args . Fullfilled "_backward_arctan(ndarray)" args =>
-                   ArgsHMap "_backward_arctan(ndarray)" args -> IO [NDArrayHandle]
-_backward_arctan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arctan_upd ::
-                     forall args . Fullfilled "_backward_arctan(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_arctan(ndarray)" args -> IO ()
-_backward_arctan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "degrees(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-degrees ::
-        forall args . Fullfilled "degrees(ndarray)" args =>
-          ArgsHMap "degrees(ndarray)" args -> IO [NDArrayHandle]
-degrees args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-degrees_upd ::
-            forall args . Fullfilled "degrees(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "degrees(ndarray)" args -> IO ()
-degrees_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_degrees(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_degrees ::
-                  forall args . Fullfilled "_backward_degrees(ndarray)" args =>
-                    ArgsHMap "_backward_degrees(ndarray)" args -> IO [NDArrayHandle]
-_backward_degrees args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_degrees_upd ::
-                      forall args . Fullfilled "_backward_degrees(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_degrees(ndarray)" args -> IO ()
-_backward_degrees_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "radians(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-radians ::
-        forall args . Fullfilled "radians(ndarray)" args =>
-          ArgsHMap "radians(ndarray)" args -> IO [NDArrayHandle]
-radians args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-radians_upd ::
-            forall args . Fullfilled "radians(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "radians(ndarray)" args -> IO ()
-radians_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_radians(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_radians ::
-                  forall args . Fullfilled "_backward_radians(ndarray)" args =>
-                    ArgsHMap "_backward_radians(ndarray)" args -> IO [NDArrayHandle]
-_backward_radians args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_radians_upd ::
-                      forall args . Fullfilled "_backward_radians(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_radians(ndarray)" args -> IO ()
-_backward_radians_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sinh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sinh ::
-     forall args . Fullfilled "sinh(ndarray)" args =>
-       ArgsHMap "sinh(ndarray)" args -> IO [NDArrayHandle]
-sinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sinh_upd ::
-         forall args . Fullfilled "sinh(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sinh(ndarray)" args -> IO ()
-sinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sinh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sinh ::
-               forall args . Fullfilled "_backward_sinh(ndarray)" args =>
-                 ArgsHMap "_backward_sinh(ndarray)" args -> IO [NDArrayHandle]
-_backward_sinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sinh_upd ::
-                   forall args . Fullfilled "_backward_sinh(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_sinh(ndarray)" args -> IO ()
-_backward_sinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cosh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-cosh ::
-     forall args . Fullfilled "cosh(ndarray)" args =>
-       ArgsHMap "cosh(ndarray)" args -> IO [NDArrayHandle]
-cosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cosh_upd ::
-         forall args . Fullfilled "cosh(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "cosh(ndarray)" args -> IO ()
-cosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cosh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_cosh ::
-               forall args . Fullfilled "_backward_cosh(ndarray)" args =>
-                 ArgsHMap "_backward_cosh(ndarray)" args -> IO [NDArrayHandle]
-_backward_cosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cosh_upd ::
-                   forall args . Fullfilled "_backward_cosh(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cosh(ndarray)" args -> IO ()
-_backward_cosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "tanh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-tanh ::
-     forall args . Fullfilled "tanh(ndarray)" args =>
-       ArgsHMap "tanh(ndarray)" args -> IO [NDArrayHandle]
-tanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-tanh_upd ::
-         forall args . Fullfilled "tanh(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "tanh(ndarray)" args -> IO ()
-tanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_tanh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_tanh ::
-               forall args . Fullfilled "_backward_tanh(ndarray)" args =>
-                 ArgsHMap "_backward_tanh(ndarray)" args -> IO [NDArrayHandle]
-_backward_tanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_tanh_upd ::
-                   forall args . Fullfilled "_backward_tanh(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_tanh(ndarray)" args -> IO ()
-_backward_tanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arcsinh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arcsinh ::
-        forall args . Fullfilled "arcsinh(ndarray)" args =>
-          ArgsHMap "arcsinh(ndarray)" args -> IO [NDArrayHandle]
-arcsinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arcsinh_upd ::
-            forall args . Fullfilled "arcsinh(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "arcsinh(ndarray)" args -> IO ()
-arcsinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arcsinh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arcsinh ::
-                  forall args . Fullfilled "_backward_arcsinh(ndarray)" args =>
-                    ArgsHMap "_backward_arcsinh(ndarray)" args -> IO [NDArrayHandle]
-_backward_arcsinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arcsinh_upd ::
-                      forall args . Fullfilled "_backward_arcsinh(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_arcsinh(ndarray)" args -> IO ()
-_backward_arcsinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arccosh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arccosh ::
-        forall args . Fullfilled "arccosh(ndarray)" args =>
-          ArgsHMap "arccosh(ndarray)" args -> IO [NDArrayHandle]
-arccosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arccosh_upd ::
-            forall args . Fullfilled "arccosh(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "arccosh(ndarray)" args -> IO ()
-arccosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arccosh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arccosh ::
-                  forall args . Fullfilled "_backward_arccosh(ndarray)" args =>
-                    ArgsHMap "_backward_arccosh(ndarray)" args -> IO [NDArrayHandle]
-_backward_arccosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arccosh_upd ::
-                      forall args . Fullfilled "_backward_arccosh(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_arccosh(ndarray)" args -> IO ()
-_backward_arccosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arctanh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arctanh ::
-        forall args . Fullfilled "arctanh(ndarray)" args =>
-          ArgsHMap "arctanh(ndarray)" args -> IO [NDArrayHandle]
-arctanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arctanh_upd ::
-            forall args . Fullfilled "arctanh(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "arctanh(ndarray)" args -> IO ()
-arctanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arctanh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arctanh ::
-                  forall args . Fullfilled "_backward_arctanh(ndarray)" args =>
-                    ArgsHMap "_backward_arctanh(ndarray)" args -> IO [NDArrayHandle]
-_backward_arctanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arctanh_upd ::
-                      forall args . Fullfilled "_backward_arctanh(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_arctanh(ndarray)" args -> IO ()
-_backward_arctanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_dequantize(ndarray)" =
-     '[ '("out_type", AttrReq (EnumType '["float32"])),
-        '("input", AttrOpt NDArrayHandle),
-        '("min_range", AttrOpt NDArrayHandle),
-        '("max_range", AttrOpt NDArrayHandle)]
-
-_contrib_dequantize ::
-                    forall args . Fullfilled "_contrib_dequantize(ndarray)" args =>
-                      ArgsHMap "_contrib_dequantize(ndarray)" args -> IO [NDArrayHandle]
-_contrib_dequantize args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["float32"]))]
-        tensorArgs
-          = catMaybes
-              [("input",) <$> (args !? #input :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dequantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_dequantize_upd ::
-                        forall args . Fullfilled "_contrib_dequantize(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_contrib_dequantize(ndarray)" args -> IO ()
-_contrib_dequantize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["float32"]))]
-        tensorArgs
-          = catMaybes
-              [("input",) <$> (args !? #input :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dequantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_CTCLoss(ndarray)" =
-     '[ '("use_data_lengths", AttrOpt Bool),
-        '("use_label_lengths", AttrOpt Bool),
-        '("blank_label", AttrOpt (EnumType '["first", "last"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle),
-        '("data_lengths", AttrOpt NDArrayHandle),
-        '("label_lengths", AttrOpt NDArrayHandle)]
-
-_contrib_CTCLoss ::
-                 forall args . Fullfilled "_contrib_CTCLoss(ndarray)" args =>
-                   ArgsHMap "_contrib_CTCLoss(ndarray)" args -> IO [NDArrayHandle]
-_contrib_CTCLoss args
-  = let scalarArgs
-          = catMaybes
-              [("use_data_lengths",) . showValue <$>
-                 (args !? #use_data_lengths :: Maybe Bool),
-               ("use_label_lengths",) . showValue <$>
-                 (args !? #use_label_lengths :: Maybe Bool),
-               ("blank_label",) . showValue <$>
-                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("data_lengths",) <$>
-                 (args !? #data_lengths :: Maybe NDArrayHandle),
-               ("label_lengths",) <$>
-                 (args !? #label_lengths :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_CTCLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_CTCLoss_upd ::
-                     forall args . Fullfilled "_contrib_CTCLoss(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_contrib_CTCLoss(ndarray)" args -> IO ()
-_contrib_CTCLoss_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_data_lengths",) . showValue <$>
-                 (args !? #use_data_lengths :: Maybe Bool),
-               ("use_label_lengths",) . showValue <$>
-                 (args !? #use_label_lengths :: Maybe Bool),
-               ("blank_label",) . showValue <$>
-                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("data_lengths",) <$>
-                 (args !? #data_lengths :: Maybe NDArrayHandle),
-               ("label_lengths",) <$>
-                 (args !? #label_lengths :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_CTCLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantize(ndarray)" =
-     '[ '("out_type", AttrOpt (EnumType '["uint8"])),
-        '("input", AttrOpt NDArrayHandle),
-        '("min_range", AttrOpt NDArrayHandle),
-        '("max_range", AttrOpt NDArrayHandle)]
-
-_contrib_quantize ::
-                  forall args . Fullfilled "_contrib_quantize(ndarray)" args =>
-                    ArgsHMap "_contrib_quantize(ndarray)" args -> IO [NDArrayHandle]
-_contrib_quantize args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("input",) <$> (args !? #input :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantize_upd ::
-                      forall args . Fullfilled "_contrib_quantize(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_contrib_quantize(ndarray)" args -> IO ()
-_contrib_quantize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("input",) <$> (args !? #input :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Custom(ndarray)" = '[]
-
-_backward_Custom ::
-                 forall args . Fullfilled "_backward_Custom(ndarray)" args =>
-                   ArgsHMap "_backward_Custom(ndarray)" args -> IO [NDArrayHandle]
-_backward_Custom args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Custom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Custom_upd ::
-                     forall args . Fullfilled "_backward_Custom(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_Custom(ndarray)" args -> IO ()
-_backward_Custom_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Custom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_multinomial(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),
-        '("dtype", AttrOpt (EnumType '["int32"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_sample_multinomial ::
-                    forall args . Fullfilled "_sample_multinomial(ndarray)" args =>
-                      ArgsHMap "_sample_multinomial(ndarray)" args -> IO [NDArrayHandle]
-_sample_multinomial args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype :: Maybe (EnumType '["int32"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_multinomial_upd ::
-                        forall args . Fullfilled "_sample_multinomial(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_sample_multinomial(ndarray)" args -> IO ()
-_sample_multinomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype :: Maybe (EnumType '["int32"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sample_multinomial(ndarray)"
-     = '[]
-
-_backward_sample_multinomial ::
-                             forall args .
-                               Fullfilled "_backward_sample_multinomial(ndarray)" args =>
-                               ArgsHMap "_backward_sample_multinomial(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_backward_sample_multinomial args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sample_multinomial_upd ::
-                                 forall args .
-                                   Fullfilled "_backward_sample_multinomial(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_backward_sample_multinomial(ndarray)" args -> IO ()
-_backward_sample_multinomial_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_uniform(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("low", AttrOpt NDArrayHandle), '("high", AttrOpt NDArrayHandle)]
-
-_sample_uniform ::
-                forall args . Fullfilled "_sample_uniform(ndarray)" args =>
-                  ArgsHMap "_sample_uniform(ndarray)" args -> IO [NDArrayHandle]
-_sample_uniform args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("low",) <$> (args !? #low :: Maybe NDArrayHandle),
-               ("high",) <$> (args !? #high :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_uniform_upd ::
-                    forall args . Fullfilled "_sample_uniform(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_sample_uniform(ndarray)" args -> IO ()
-_sample_uniform_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("low",) <$> (args !? #low :: Maybe NDArrayHandle),
-               ("high",) <$> (args !? #high :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_normal(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt NDArrayHandle), '("sigma", AttrOpt NDArrayHandle)]
-
-_sample_normal ::
-               forall args . Fullfilled "_sample_normal(ndarray)" args =>
-                 ArgsHMap "_sample_normal(ndarray)" args -> IO [NDArrayHandle]
-_sample_normal args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_normal_upd ::
-                   forall args . Fullfilled "_sample_normal(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_sample_normal(ndarray)" args -> IO ()
-_sample_normal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_gamma(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("alpha", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_sample_gamma ::
-              forall args . Fullfilled "_sample_gamma(ndarray)" args =>
-                ArgsHMap "_sample_gamma(ndarray)" args -> IO [NDArrayHandle]
-_sample_gamma args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_gamma_upd ::
-                  forall args . Fullfilled "_sample_gamma(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_sample_gamma(ndarray)" args -> IO ()
-_sample_gamma_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_exponential(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt NDArrayHandle)]
-
-_sample_exponential ::
-                    forall args . Fullfilled "_sample_exponential(ndarray)" args =>
-                      ArgsHMap "_sample_exponential(ndarray)" args -> IO [NDArrayHandle]
-_sample_exponential args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_exponential_upd ::
-                        forall args . Fullfilled "_sample_exponential(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_sample_exponential(ndarray)" args -> IO ()
-_sample_exponential_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_poisson(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt NDArrayHandle)]
-
-_sample_poisson ::
-                forall args . Fullfilled "_sample_poisson(ndarray)" args =>
-                  ArgsHMap "_sample_poisson(ndarray)" args -> IO [NDArrayHandle]
-_sample_poisson args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_poisson_upd ::
-                    forall args . Fullfilled "_sample_poisson(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_sample_poisson(ndarray)" args -> IO ()
-_sample_poisson_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_negative_binomial(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("k", AttrOpt NDArrayHandle), '("p", AttrOpt NDArrayHandle)]
-
-_sample_negative_binomial ::
-                          forall args .
-                            Fullfilled "_sample_negative_binomial(ndarray)" args =>
-                            ArgsHMap "_sample_negative_binomial(ndarray)" args ->
-                              IO [NDArrayHandle]
-_sample_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("k",) <$> (args !? #k :: Maybe NDArrayHandle),
-               ("p",) <$> (args !? #p :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_negative_binomial_upd ::
-                              forall args .
-                                Fullfilled "_sample_negative_binomial(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_sample_negative_binomial(ndarray)" args -> IO ()
-_sample_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("k",) <$> (args !? #k :: Maybe NDArrayHandle),
-               ("p",) <$> (args !? #p :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_sample_generalized_negative_binomial(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt NDArrayHandle), '("alpha", AttrOpt NDArrayHandle)]
-
-_sample_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_sample_generalized_negative_binomial(ndarray)"
-                                          args =>
-                                        ArgsHMap "_sample_generalized_negative_binomial(ndarray)"
-                                          args
-                                          -> IO [NDArrayHandle]
-_sample_generalized_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_generalized_negative_binomial_upd ::
-                                          forall args .
-                                            Fullfilled
-                                              "_sample_generalized_negative_binomial(ndarray)"
-                                              args =>
-                                            [NDArrayHandle] ->
-                                              ArgsHMap
-                                                "_sample_generalized_negative_binomial(ndarray)"
-                                                args
-                                                -> IO ()
-_sample_generalized_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_uniform(ndarray)" =
-     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_uniform ::
-                forall args . Fullfilled "_random_uniform(ndarray)" args =>
-                  ArgsHMap "_random_uniform(ndarray)" args -> IO [NDArrayHandle]
-_random_uniform args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_uniform_upd ::
-                    forall args . Fullfilled "_random_uniform(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_random_uniform(ndarray)" args -> IO ()
-_random_uniform_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_normal(ndarray)" =
-     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_normal ::
-               forall args . Fullfilled "_random_normal(ndarray)" args =>
-                 ArgsHMap "_random_normal(ndarray)" args -> IO [NDArrayHandle]
-_random_normal args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_normal_upd ::
-                   forall args . Fullfilled "_random_normal(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_random_normal(ndarray)" args -> IO ()
-_random_normal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_gamma(ndarray)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_gamma ::
-              forall args . Fullfilled "_random_gamma(ndarray)" args =>
-                ArgsHMap "_random_gamma(ndarray)" args -> IO [NDArrayHandle]
-_random_gamma args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_gamma_upd ::
-                  forall args . Fullfilled "_random_gamma(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_random_gamma(ndarray)" args -> IO ()
-_random_gamma_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_exponential(ndarray)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_exponential ::
-                    forall args . Fullfilled "_random_exponential(ndarray)" args =>
-                      ArgsHMap "_random_exponential(ndarray)" args -> IO [NDArrayHandle]
-_random_exponential args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_exponential_upd ::
-                        forall args . Fullfilled "_random_exponential(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_random_exponential(ndarray)" args -> IO ()
-_random_exponential_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_poisson(ndarray)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_poisson ::
-                forall args . Fullfilled "_random_poisson(ndarray)" args =>
-                  ArgsHMap "_random_poisson(ndarray)" args -> IO [NDArrayHandle]
-_random_poisson args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_poisson_upd ::
-                    forall args . Fullfilled "_random_poisson(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_random_poisson(ndarray)" args -> IO ()
-_random_poisson_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_negative_binomial(ndarray)" =
-     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_negative_binomial ::
-                          forall args .
-                            Fullfilled "_random_negative_binomial(ndarray)" args =>
-                            ArgsHMap "_random_negative_binomial(ndarray)" args ->
-                              IO [NDArrayHandle]
-_random_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_negative_binomial_upd ::
-                              forall args .
-                                Fullfilled "_random_negative_binomial(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_random_negative_binomial(ndarray)" args -> IO ()
-_random_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_random_generalized_negative_binomial(ndarray)" =
-     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_random_generalized_negative_binomial(ndarray)"
-                                          args =>
-                                        ArgsHMap "_random_generalized_negative_binomial(ndarray)"
-                                          args
-                                          -> IO [NDArrayHandle]
-_random_generalized_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_generalized_negative_binomial_upd ::
-                                          forall args .
-                                            Fullfilled
-                                              "_random_generalized_negative_binomial(ndarray)"
-                                              args =>
-                                            [NDArrayHandle] ->
-                                              ArgsHMap
-                                                "_random_generalized_negative_binomial(ndarray)"
-                                                args
-                                                -> IO ()
-_random_generalized_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "softmax(ndarray)" =
-     '[ '("axis", AttrOpt Int), '("data", AttrOpt NDArrayHandle)]
-
-softmax ::
-        forall args . Fullfilled "softmax(ndarray)" args =>
-          ArgsHMap "softmax(ndarray)" args -> IO [NDArrayHandle]
-softmax args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-softmax_upd ::
-            forall args . Fullfilled "softmax(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "softmax(ndarray)" args -> IO ()
-softmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_softmax(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_softmax ::
-                  forall args . Fullfilled "_backward_softmax(ndarray)" args =>
-                    ArgsHMap "_backward_softmax(ndarray)" args -> IO [NDArrayHandle]
-_backward_softmax args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_softmax_upd ::
-                      forall args . Fullfilled "_backward_softmax(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_softmax(ndarray)" args -> IO ()
-_backward_softmax_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log_softmax(ndarray)" =
-     '[ '("axis", AttrOpt Int), '("data", AttrOpt NDArrayHandle)]
-
-log_softmax ::
-            forall args . Fullfilled "log_softmax(ndarray)" args =>
-              ArgsHMap "log_softmax(ndarray)" args -> IO [NDArrayHandle]
-log_softmax args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log_softmax_upd ::
-                forall args . Fullfilled "log_softmax(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "log_softmax(ndarray)" args -> IO ()
-log_softmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log_softmax(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log_softmax ::
-                      forall args . Fullfilled "_backward_log_softmax(ndarray)" args =>
-                        ArgsHMap "_backward_log_softmax(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_log_softmax args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log_softmax_upd ::
-                          forall args . Fullfilled "_backward_log_softmax(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_log_softmax(ndarray)" args -> IO ()
-_backward_log_softmax_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvimdecode(ndarray)" =
-     '[ '("flag", AttrOpt Int), '("to_rgb", AttrOpt Bool),
-        '("buf", AttrOpt NDArrayHandle)]
-
-_cvimdecode ::
-            forall args . Fullfilled "_cvimdecode(ndarray)" args =>
-              ArgsHMap "_cvimdecode(ndarray)" args -> IO [NDArrayHandle]
-_cvimdecode args
-  = let scalarArgs
-          = catMaybes
-              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvimdecode_upd ::
-                forall args . Fullfilled "_cvimdecode(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_cvimdecode(ndarray)" args -> IO ()
-_cvimdecode_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvimread(ndarray)" =
-     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),
-        '("to_rgb", AttrOpt Bool)]
-
-_cvimread ::
-          forall args . Fullfilled "_cvimread(ndarray)" args =>
-            ArgsHMap "_cvimread(ndarray)" args -> IO [NDArrayHandle]
-_cvimread args
-  = let scalarArgs
-          = catMaybes
-              [("filename",) . showValue <$> (args !? #filename :: Maybe String),
-               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimread"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvimread_upd ::
-              forall args . Fullfilled "_cvimread(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_cvimread(ndarray)" args -> IO ()
-_cvimread_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("filename",) . showValue <$> (args !? #filename :: Maybe String),
-               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimread"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvimresize(ndarray)" =
-     '[ '("w", AttrReq Int), '("h", AttrReq Int),
-        '("interp", AttrOpt Int), '("src", AttrOpt NDArrayHandle)]
-
-_cvimresize ::
-            forall args . Fullfilled "_cvimresize(ndarray)" args =>
-              ArgsHMap "_cvimresize(ndarray)" args -> IO [NDArrayHandle]
-_cvimresize args
-  = let scalarArgs
-          = catMaybes
-              [("w",) . showValue <$> (args !? #w :: Maybe Int),
-               ("h",) . showValue <$> (args !? #h :: Maybe Int),
-               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimresize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvimresize_upd ::
-                forall args . Fullfilled "_cvimresize(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_cvimresize(ndarray)" args -> IO ()
-_cvimresize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("w",) . showValue <$> (args !? #w :: Maybe Int),
-               ("h",) . showValue <$> (args !? #h :: Maybe Int),
-               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimresize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvcopyMakeBorder(ndarray)" =
-     '[ '("top", AttrReq Int), '("bot", AttrReq Int),
-        '("left", AttrReq Int), '("right", AttrReq Int),
-        '("type", AttrOpt Int), '("value", AttrOpt Double),
-        '("values", AttrOpt [Double]), '("src", AttrOpt NDArrayHandle)]
-
-_cvcopyMakeBorder ::
-                  forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args =>
-                    ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO [NDArrayHandle]
-_cvcopyMakeBorder args
-  = let scalarArgs
-          = catMaybes
-              [("top",) . showValue <$> (args !? #top :: Maybe Int),
-               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),
-               ("left",) . showValue <$> (args !? #left :: Maybe Int),
-               ("right",) . showValue <$> (args !? #right :: Maybe Int),
-               ("type",) . showValue <$> (args !? #type :: Maybe Int),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double),
-               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvcopyMakeBorder"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvcopyMakeBorder_upd ::
-                      forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO ()
-_cvcopyMakeBorder_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("top",) . showValue <$> (args !? #top :: Maybe Int),
-               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),
-               ("left",) . showValue <$> (args !? #left :: Maybe Int),
-               ("right",) . showValue <$> (args !? #right :: Maybe Int),
-               ("type",) . showValue <$> (args !? #type :: Maybe Int),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double),
-               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvcopyMakeBorder"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_NoGradient(ndarray)" = '[]
-
-_NoGradient ::
-            forall args . Fullfilled "_NoGradient(ndarray)" args =>
-              ArgsHMap "_NoGradient(ndarray)" args -> IO [NDArrayHandle]
-_NoGradient args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_NoGradient"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_NoGradient_upd ::
-                forall args . Fullfilled "_NoGradient(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_NoGradient(ndarray)" args -> IO ()
-_NoGradient_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_NoGradient"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CachedOp(ndarray)" = '[]
-
-_CachedOp ::
-          forall args . Fullfilled "_CachedOp(ndarray)" args =>
-            ArgsHMap "_CachedOp(ndarray)" args -> IO [NDArrayHandle]
-_CachedOp args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CachedOp_upd ::
-              forall args . Fullfilled "_CachedOp(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_CachedOp(ndarray)" args -> IO ()
-_CachedOp_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_CachedOp(ndarray)" = '[]
-
-_backward_CachedOp ::
-                   forall args . Fullfilled "_backward_CachedOp(ndarray)" args =>
-                     ArgsHMap "_backward_CachedOp(ndarray)" args -> IO [NDArrayHandle]
-_backward_CachedOp args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_CachedOp_upd ::
-                       forall args . Fullfilled "_backward_CachedOp(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_CachedOp(ndarray)" args -> IO ()
-_backward_CachedOp_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_copyto(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_copyto ::
-        forall args . Fullfilled "_copyto(ndarray)" args =>
-          ArgsHMap "_copyto(ndarray)" args -> IO [NDArrayHandle]
-_copyto args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copyto"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_copyto_upd ::
-            forall args . Fullfilled "_copyto(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_copyto(ndarray)" args -> IO ()
-_copyto_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copyto"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SwapAxis(ndarray)" =
-     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_SwapAxis ::
-          forall args . Fullfilled "_SwapAxis(ndarray)" args =>
-            ArgsHMap "_SwapAxis(ndarray)" args -> IO [NDArrayHandle]
-_SwapAxis args
-  = let scalarArgs
-          = catMaybes
-              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),
-               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SwapAxis_upd ::
-              forall args . Fullfilled "_SwapAxis(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_SwapAxis(ndarray)" args -> IO ()
-_SwapAxis_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),
-               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Pad(ndarray)" =
-     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),
-        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Pad ::
-     forall args . Fullfilled "_Pad(ndarray)" args =>
-       ArgsHMap "_Pad(ndarray)" args -> IO [NDArrayHandle]
-_Pad args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["constant", "edge", "reflect"])),
-               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),
-               ("constant_value",) . showValue <$>
-                 (args !? #constant_value :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Pad_upd ::
-         forall args . Fullfilled "_Pad(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_Pad(ndarray)" args -> IO ()
-_Pad_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["constant", "edge", "reflect"])),
-               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),
-               ("constant_value",) . showValue <$>
-                 (args !? #constant_value :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BatchNorm_v1(ndarray)" =
-     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_BatchNorm_v1 ::
-              forall args . Fullfilled "_BatchNorm_v1(ndarray)" args =>
-                ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO [NDArrayHandle]
-_BatchNorm_v1 args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BatchNorm_v1_upd ::
-                  forall args . Fullfilled "_BatchNorm_v1(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO ()
-_BatchNorm_v1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sgd_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle)]
-
-sgd_update ::
-           forall args . Fullfilled "sgd_update(ndarray)" args =>
-             ArgsHMap "sgd_update(ndarray)" args -> IO [NDArrayHandle]
-sgd_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sgd_update_upd ::
-               forall args . Fullfilled "sgd_update(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "sgd_update(ndarray)" args -> IO ()
-sgd_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sgd_mom_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]
-
-sgd_mom_update ::
-               forall args . Fullfilled "sgd_mom_update(ndarray)" args =>
-                 ArgsHMap "sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]
-sgd_mom_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sgd_mom_update_upd ::
-                   forall args . Fullfilled "sgd_mom_update(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "sgd_mom_update(ndarray)" args -> IO ()
-sgd_mom_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "mp_sgd_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle),
-        '("weight32", AttrOpt NDArrayHandle)]
-
-mp_sgd_update ::
-              forall args . Fullfilled "mp_sgd_update(ndarray)" args =>
-                ArgsHMap "mp_sgd_update(ndarray)" args -> IO [NDArrayHandle]
-mp_sgd_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-mp_sgd_update_upd ::
-                  forall args . Fullfilled "mp_sgd_update(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "mp_sgd_update(ndarray)" args -> IO ()
-mp_sgd_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "mp_sgd_mom_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle),
-        '("weight32", AttrOpt NDArrayHandle)]
-
-mp_sgd_mom_update ::
-                  forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args =>
-                    ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]
-mp_sgd_mom_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-mp_sgd_mom_update_upd ::
-                      forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO ()
-mp_sgd_mom_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "adam_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle),
-        '("var", AttrOpt NDArrayHandle)]
-
-adam_update ::
-            forall args . Fullfilled "adam_update(ndarray)" args =>
-              ArgsHMap "adam_update(ndarray)" args -> IO [NDArrayHandle]
-adam_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),
-               ("var",) <$> (args !? #var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "adam_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-adam_update_upd ::
-                forall args . Fullfilled "adam_update(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "adam_update(ndarray)" args -> IO ()
-adam_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),
-               ("var",) <$> (args !? #var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "adam_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rmsprop_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle)]
-
-rmsprop_update ::
-               forall args . Fullfilled "rmsprop_update(ndarray)" args =>
-                 ArgsHMap "rmsprop_update(ndarray)" args -> IO [NDArrayHandle]
-rmsprop_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmsprop_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rmsprop_update_upd ::
-                   forall args . Fullfilled "rmsprop_update(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "rmsprop_update(ndarray)" args -> IO ()
-rmsprop_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmsprop_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rmspropalex_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle),
-        '("g", AttrOpt NDArrayHandle), '("delta", AttrOpt NDArrayHandle)]
-
-rmspropalex_update ::
-                   forall args . Fullfilled "rmspropalex_update(ndarray)" args =>
-                     ArgsHMap "rmspropalex_update(ndarray)" args -> IO [NDArrayHandle]
-rmspropalex_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle),
-               ("g",) <$> (args !? #g :: Maybe NDArrayHandle),
-               ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmspropalex_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rmspropalex_update_upd ::
-                       forall args . Fullfilled "rmspropalex_update(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "rmspropalex_update(ndarray)" args -> IO ()
-rmspropalex_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle),
-               ("g",) <$> (args !? #g :: Maybe NDArrayHandle),
-               ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmspropalex_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ftrl_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),
-        '("beta", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle),
-        '("n", AttrOpt NDArrayHandle)]
-
-ftrl_update ::
-            forall args . Fullfilled "ftrl_update(ndarray)" args =>
-              ArgsHMap "ftrl_update(ndarray)" args -> IO [NDArrayHandle]
-ftrl_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("z",) <$> (args !? #z :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftrl_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ftrl_update_upd ::
-                forall args . Fullfilled "ftrl_update(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "ftrl_update(ndarray)" args -> IO ()
-ftrl_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("z",) <$> (args !? #z :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftrl_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LeakyReLU(ndarray)" =
-     '[ '("act_type",
-          AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu"])),
-        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),
-        '("upper_bound", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_LeakyReLU ::
-           forall args . Fullfilled "_LeakyReLU(ndarray)" args =>
-             ArgsHMap "_LeakyReLU(ndarray)" args -> IO [NDArrayHandle]
-_LeakyReLU args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu"])),
-               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),
-               ("lower_bound",) . showValue <$>
-                 (args !? #lower_bound :: Maybe Float),
-               ("upper_bound",) . showValue <$>
-                 (args !? #upper_bound :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LeakyReLU_upd ::
-               forall args . Fullfilled "_LeakyReLU(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_LeakyReLU(ndarray)" args -> IO ()
-_LeakyReLU_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu"])),
-               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),
-               ("lower_bound",) . showValue <$>
-                 (args !? #lower_bound :: Maybe Float),
-               ("upper_bound",) . showValue <$>
-                 (args !? #upper_bound :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_IdentityAttachKLSparseReg(ndarray)" =
-     '[ '("sparseness_target", AttrOpt Float),
-        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_IdentityAttachKLSparseReg ::
-                           forall args .
-                             Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args =>
-                             ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args ->
-                               IO [NDArrayHandle]
-_IdentityAttachKLSparseReg args
-  = let scalarArgs
-          = catMaybes
-              [("sparseness_target",) . showValue <$>
-                 (args !? #sparseness_target :: Maybe Float),
-               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_IdentityAttachKLSparseReg_upd ::
-                               forall args .
-                                 Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> IO ()
-_IdentityAttachKLSparseReg_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("sparseness_target",) . showValue <$>
-                 (args !? #sparseness_target :: Maybe Float),
-               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_UpSampling(ndarray)" =
-     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),
-        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),
-        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),
-        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_UpSampling ::
-            forall args . Fullfilled "_UpSampling(ndarray)" args =>
-              ArgsHMap "_UpSampling(ndarray)" args -> IO [NDArrayHandle]
-_UpSampling args
-  = let scalarArgs
-          = catMaybes
-              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("sample_type",) . showValue <$>
-                 (args !? #sample_type ::
-                    Maybe (EnumType '["bilinear", "nearest"])),
-               ("multi_input_mode",) . showValue <$>
-                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "UpSampling"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_UpSampling_upd ::
-                forall args . Fullfilled "_UpSampling(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_UpSampling(ndarray)" args -> IO ()
-_UpSampling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("sample_type",) . showValue <$>
-                 (args !? #sample_type ::
-                    Maybe (EnumType '["bilinear", "nearest"])),
-               ("multi_input_mode",) . showValue <$>
-                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "UpSampling"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SliceChannel(ndarray)" =
-     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),
-        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-_SliceChannel ::
-              forall args . Fullfilled "_SliceChannel(ndarray)" args =>
-                ArgsHMap "_SliceChannel(ndarray)" args -> IO [NDArrayHandle]
-_SliceChannel args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SliceChannel_upd ::
-                  forall args . Fullfilled "_SliceChannel(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_SliceChannel(ndarray)" args -> IO ()
-_SliceChannel_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CuDNNBatchNorm(ndarray)" =
-     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-_CuDNNBatchNorm ::
-                forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args =>
-                  ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO [NDArrayHandle]
-_CuDNNBatchNorm args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CuDNNBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CuDNNBatchNorm_upd ::
-                    forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO ()
-_CuDNNBatchNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CuDNNBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "softmax_cross_entropy(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-softmax_cross_entropy ::
-                      forall args . Fullfilled "softmax_cross_entropy(ndarray)" args =>
-                        ArgsHMap "softmax_cross_entropy(ndarray)" args ->
-                          IO [NDArrayHandle]
-softmax_cross_entropy args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-softmax_cross_entropy_upd ::
-                          forall args . Fullfilled "softmax_cross_entropy(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "softmax_cross_entropy(ndarray)" args -> IO ()
-softmax_cross_entropy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_softmax_cross_entropy(ndarray)" = '[]
-
-_backward_softmax_cross_entropy ::
-                                forall args .
-                                  Fullfilled "_backward_softmax_cross_entropy(ndarray)" args =>
-                                  ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args ->
-                                    IO [NDArrayHandle]
-_backward_softmax_cross_entropy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_softmax_cross_entropy_upd ::
-                                    forall args .
-                                      Fullfilled "_backward_softmax_cross_entropy(ndarray)" args =>
-                                      [NDArrayHandle] ->
-                                        ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args ->
-                                          IO ()
-_backward_softmax_cross_entropy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Concat(ndarray)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_Concat ::
-        forall args . Fullfilled "_Concat(ndarray)" args =>
-          ArgsHMap "_Concat(ndarray)" args -> IO [NDArrayHandle]
-_Concat args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_Concat_upd ::
-            forall args . Fullfilled "_Concat(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_Concat(ndarray)" args -> IO ()
-_Concat_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BatchNorm(ndarray)" =
-     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle),
-        '("moving_mean", AttrOpt NDArrayHandle),
-        '("moving_var", AttrOpt NDArrayHandle)]
-
-_BatchNorm ::
-           forall args . Fullfilled "_BatchNorm(ndarray)" args =>
-             ArgsHMap "_BatchNorm(ndarray)" args -> IO [NDArrayHandle]
-_BatchNorm args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BatchNorm_upd ::
-               forall args . Fullfilled "_BatchNorm(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_BatchNorm(ndarray)" args -> IO ()
-_BatchNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CustomFunction(ndarray)" = '[]
-
-_CustomFunction ::
-                forall args . Fullfilled "_CustomFunction(ndarray)" args =>
-                  ArgsHMap "_CustomFunction(ndarray)" args -> IO [NDArrayHandle]
-_CustomFunction args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CustomFunction_upd ::
-                    forall args . Fullfilled "_CustomFunction(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_CustomFunction(ndarray)" args -> IO ()
-_CustomFunction_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_CustomFunction(ndarray)" =
-     '[]
-
-_backward_CustomFunction ::
-                         forall args .
-                           Fullfilled "_backward_CustomFunction(ndarray)" args =>
-                           ArgsHMap "_backward_CustomFunction(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_CustomFunction args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_CustomFunction_upd ::
-                             forall args .
-                               Fullfilled "_backward_CustomFunction(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_CustomFunction(ndarray)" args -> IO ()
-_backward_CustomFunction_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiBoxTarget(ndarray)" =
-     '[ '("overlap_threshold", AttrOpt Float),
-        '("ignore_label", AttrOpt Float),
-        '("negative_mining_ratio", AttrOpt Float),
-        '("negative_mining_thresh", AttrOpt Float),
-        '("minimum_negative_samples", AttrOpt Int),
-        '("variances", AttrOpt [Float]),
-        '("anchor", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle),
-        '("cls_pred", AttrOpt NDArrayHandle)]
-
-_contrib_MultiBoxTarget ::
-                        forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args =>
-                          ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args ->
-                            IO [NDArrayHandle]
-_contrib_MultiBoxTarget args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_threshold",) . showValue <$>
-                 (args !? #overlap_threshold :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("negative_mining_ratio",) . showValue <$>
-                 (args !? #negative_mining_ratio :: Maybe Float),
-               ("negative_mining_thresh",) . showValue <$>
-                 (args !? #negative_mining_thresh :: Maybe Float),
-               ("minimum_negative_samples",) . showValue <$>
-                 (args !? #minimum_negative_samples :: Maybe Int),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float])]
-        tensorArgs
-          = catMaybes
-              [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiBoxTarget_upd ::
-                            forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> IO ()
-_contrib_MultiBoxTarget_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_threshold",) . showValue <$>
-                 (args !? #overlap_threshold :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("negative_mining_ratio",) . showValue <$>
-                 (args !? #negative_mining_ratio :: Maybe Float),
-               ("negative_mining_thresh",) . showValue <$>
-                 (args !? #negative_mining_thresh :: Maybe Float),
-               ("minimum_negative_samples",) . showValue <$>
-                 (args !? #minimum_negative_samples :: Maybe Int),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float])]
-        tensorArgs
-          = catMaybes
-              [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxTarget(ndarray)" = '[]
-
-_backward__contrib_MultiBoxTarget ::
-                                  forall args .
-                                    Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" args =>
-                                    ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args ->
-                                      IO [NDArrayHandle]
-_backward__contrib_MultiBoxTarget args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiBoxTarget_upd ::
-                                      forall args .
-                                        Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)"
-                                          args =>
-                                        [NDArrayHandle] ->
-                                          ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args
-                                            -> IO ()
-_backward__contrib_MultiBoxTarget_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_Proposal(ndarray)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_score", AttrOpt NDArrayHandle),
-        '("bbox_pred", AttrOpt NDArrayHandle),
-        '("im_info", AttrOpt NDArrayHandle)]
-
-_contrib_Proposal ::
-                  forall args . Fullfilled "_contrib_Proposal(ndarray)" args =>
-                    ArgsHMap "_contrib_Proposal(ndarray)" args -> IO [NDArrayHandle]
-_contrib_Proposal args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_score",) <$> (args !? #cls_score :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_Proposal_upd ::
-                      forall args . Fullfilled "_contrib_Proposal(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_contrib_Proposal(ndarray)" args -> IO ()
-_contrib_Proposal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_score",) <$> (args !? #cls_score :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__contrib_Proposal(ndarray)"
-     = '[]
-
-_backward__contrib_Proposal ::
-                            forall args .
-                              Fullfilled "_backward__contrib_Proposal(ndarray)" args =>
-                              ArgsHMap "_backward__contrib_Proposal(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward__contrib_Proposal args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_Proposal_upd ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_Proposal(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> IO ()
-_backward__contrib_Proposal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_count_sketch(ndarray)" =
-     '[ '("out_dim", AttrReq Int),
-        '("processing_batch_size", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle), '("h", AttrOpt NDArrayHandle),
-        '("s", AttrOpt NDArrayHandle)]
-
-_contrib_count_sketch ::
-                      forall args . Fullfilled "_contrib_count_sketch(ndarray)" args =>
-                        ArgsHMap "_contrib_count_sketch(ndarray)" args ->
-                          IO [NDArrayHandle]
-_contrib_count_sketch args
-  = let scalarArgs
-          = catMaybes
-              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),
-               ("processing_batch_size",) . showValue <$>
-                 (args !? #processing_batch_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("h",) <$> (args !? #h :: Maybe NDArrayHandle),
-               ("s",) <$> (args !? #s :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_count_sketch_upd ::
-                          forall args . Fullfilled "_contrib_count_sketch(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_contrib_count_sketch(ndarray)" args -> IO ()
-_contrib_count_sketch_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),
-               ("processing_batch_size",) . showValue <$>
-                 (args !? #processing_batch_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("h",) <$> (args !? #h :: Maybe NDArrayHandle),
-               ("s",) <$> (args !? #s :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_count_sketch(ndarray)" = '[]
-
-_backward__contrib_count_sketch ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_count_sketch(ndarray)" args =>
-                                  ArgsHMap "_backward__contrib_count_sketch(ndarray)" args ->
-                                    IO [NDArrayHandle]
-_backward__contrib_count_sketch args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_count_sketch_upd ::
-                                    forall args .
-                                      Fullfilled "_backward__contrib_count_sketch(ndarray)" args =>
-                                      [NDArrayHandle] ->
-                                        ArgsHMap "_backward__contrib_count_sketch(ndarray)" args ->
-                                          IO ()
-_backward__contrib_count_sketch_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiBoxDetection(ndarray)" =
-     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),
-        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),
-        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),
-        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt NDArrayHandle),
-        '("loc_pred", AttrOpt NDArrayHandle),
-        '("anchor", AttrOpt NDArrayHandle)]
-
-_contrib_MultiBoxDetection ::
-                           forall args .
-                             Fullfilled "_contrib_MultiBoxDetection(ndarray)" args =>
-                             ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args ->
-                               IO [NDArrayHandle]
-_contrib_MultiBoxDetection args
-  = let scalarArgs
-          = catMaybes
-              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("nms_threshold",) . showValue <$>
-                 (args !? #nms_threshold :: Maybe Float),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float]),
-               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle),
-               ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiBoxDetection_upd ::
-                               forall args .
-                                 Fullfilled "_contrib_MultiBoxDetection(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> IO ()
-_contrib_MultiBoxDetection_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("nms_threshold",) . showValue <$>
-                 (args !? #nms_threshold :: Maybe Float),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float]),
-               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle),
-               ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxDetection(ndarray)" = '[]
-
-_backward__contrib_MultiBoxDetection ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiBoxDetection(ndarray)"
-                                         args =>
-                                       ArgsHMap "_backward__contrib_MultiBoxDetection(ndarray)" args
-                                         -> IO [NDArrayHandle]
-_backward__contrib_MultiBoxDetection args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiBoxDetection_upd ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward__contrib_MultiBoxDetection(ndarray)" args =>
-                                           [NDArrayHandle] ->
-                                             ArgsHMap
-                                               "_backward__contrib_MultiBoxDetection(ndarray)"
-                                               args
-                                               -> IO ()
-_backward__contrib_MultiBoxDetection_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_PSROIPooling(ndarray)" = '[]
-
-_backward__contrib_PSROIPooling ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args =>
-                                  ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args ->
-                                    IO [NDArrayHandle]
-_backward__contrib_PSROIPooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_PSROIPooling_upd ::
-                                    forall args .
-                                      Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args =>
-                                      [NDArrayHandle] ->
-                                        ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args ->
-                                          IO ()
-_backward__contrib_PSROIPooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_DeformablePSROIPooling(ndarray)"
-     = '[]
-
-_backward__contrib_DeformablePSROIPooling ::
-                                          forall args .
-                                            Fullfilled
-                                              "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                              args =>
-                                            ArgsHMap
-                                              "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                              args
-                                              -> IO [NDArrayHandle]
-_backward__contrib_DeformablePSROIPooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_DeformablePSROIPooling_upd ::
-                                              forall args .
-                                                Fullfilled
-                                                  "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                                  args =>
-                                                [NDArrayHandle] ->
-                                                  ArgsHMap
-                                                    "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                                    args
-                                                    -> IO ()
-_backward__contrib_DeformablePSROIPooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__contrib_CTCLoss(ndarray)" =
-     '[]
-
-_backward__contrib_CTCLoss ::
-                           forall args .
-                             Fullfilled "_backward__contrib_CTCLoss(ndarray)" args =>
-                             ArgsHMap "_backward__contrib_CTCLoss(ndarray)" args ->
-                               IO [NDArrayHandle]
-_backward__contrib_CTCLoss args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_CTCLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_CTCLoss_upd ::
-                               forall args .
-                                 Fullfilled "_backward__contrib_CTCLoss(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_backward__contrib_CTCLoss(ndarray)" args -> IO ()
-_backward__contrib_CTCLoss_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_CTCLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiProposal(ndarray)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_score", AttrOpt NDArrayHandle),
-        '("bbox_pred", AttrOpt NDArrayHandle),
-        '("im_info", AttrOpt NDArrayHandle)]
-
-_contrib_MultiProposal ::
-                       forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args =>
-                         ArgsHMap "_contrib_MultiProposal(ndarray)" args ->
-                           IO [NDArrayHandle]
-_contrib_MultiProposal args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_score",) <$> (args !? #cls_score :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiProposal_upd ::
-                           forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_contrib_MultiProposal(ndarray)" args -> IO ()
-_contrib_MultiProposal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_score",) <$> (args !? #cls_score :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiProposal(ndarray)" = '[]
-
-_backward__contrib_MultiProposal ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiProposal(ndarray)" args =>
-                                   ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args ->
-                                     IO [NDArrayHandle]
-_backward__contrib_MultiProposal args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiProposal_upd ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiProposal(ndarray)"
-                                         args =>
-                                       [NDArrayHandle] ->
-                                         ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args
-                                           -> IO ()
-_backward__contrib_MultiProposal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiBoxPrior(ndarray)" =
-     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),
-        '("offsets", AttrOpt [Float]), '("data", AttrOpt NDArrayHandle)]
-
-_contrib_MultiBoxPrior ::
-                       forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args =>
-                         ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args ->
-                           IO [NDArrayHandle]
-_contrib_MultiBoxPrior args
-  = let scalarArgs
-          = catMaybes
-              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),
-               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiBoxPrior_upd ::
-                           forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> IO ()
-_contrib_MultiBoxPrior_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),
-               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxPrior(ndarray)" = '[]
-
-_backward__contrib_MultiBoxPrior ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" args =>
-                                   ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args ->
-                                     IO [NDArrayHandle]
-_backward__contrib_MultiBoxPrior args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiBoxPrior_upd ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)"
-                                         args =>
-                                       [NDArrayHandle] ->
-                                         ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args
-                                           -> IO ()
-_backward__contrib_MultiBoxPrior_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_fft(ndarray)" =
-     '[ '("compute_size", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_fft ::
-             forall args . Fullfilled "_contrib_fft(ndarray)" args =>
-               ArgsHMap "_contrib_fft(ndarray)" args -> IO [NDArrayHandle]
-_contrib_fft args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_fft_upd ::
-                 forall args . Fullfilled "_contrib_fft(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_contrib_fft(ndarray)" args -> IO ()
-_contrib_fft_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__contrib_fft(ndarray)" = '[]
-
-_backward__contrib_fft ::
-                       forall args . Fullfilled "_backward__contrib_fft(ndarray)" args =>
-                         ArgsHMap "_backward__contrib_fft(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward__contrib_fft args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_fft_upd ::
-                           forall args . Fullfilled "_backward__contrib_fft(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward__contrib_fft(ndarray)" args -> IO ()
-_backward__contrib_fft_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_contrib_DeformableConvolution(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("num_deformable_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("offset", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_contrib_DeformableConvolution ::
-                               forall args .
-                                 Fullfilled "_contrib_DeformableConvolution(ndarray)" args =>
-                                 ArgsHMap "_contrib_DeformableConvolution(ndarray)" args ->
-                                   IO [NDArrayHandle]
-_contrib_DeformableConvolution args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("num_deformable_group",) . showValue <$>
-                 (args !? #num_deformable_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_DeformableConvolution_upd ::
-                                   forall args .
-                                     Fullfilled "_contrib_DeformableConvolution(ndarray)" args =>
-                                     [NDArrayHandle] ->
-                                       ArgsHMap "_contrib_DeformableConvolution(ndarray)" args ->
-                                         IO ()
-_contrib_DeformableConvolution_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("num_deformable_group",) . showValue <$>
-                 (args !? #num_deformable_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_DeformableConvolution(ndarray)" =
-     '[]
-
-_backward__contrib_DeformableConvolution ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward__contrib_DeformableConvolution(ndarray)"
-                                             args =>
-                                           ArgsHMap
-                                             "_backward__contrib_DeformableConvolution(ndarray)"
-                                             args
-                                             -> IO [NDArrayHandle]
-_backward__contrib_DeformableConvolution args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_DeformableConvolution_upd ::
-                                             forall args .
-                                               Fullfilled
-                                                 "_backward__contrib_DeformableConvolution(ndarray)"
-                                                 args =>
-                                               [NDArrayHandle] ->
-                                                 ArgsHMap
-                                                   "_backward__contrib_DeformableConvolution(ndarray)"
-                                                   args
-                                                   -> IO ()
-_backward__contrib_DeformableConvolution_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_ifft(ndarray)" =
-     '[ '("compute_size", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_ifft ::
-              forall args . Fullfilled "_contrib_ifft(ndarray)" args =>
-                ArgsHMap "_contrib_ifft(ndarray)" args -> IO [NDArrayHandle]
-_contrib_ifft args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_ifft_upd ::
-                  forall args . Fullfilled "_contrib_ifft(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_contrib_ifft(ndarray)" args -> IO ()
-_contrib_ifft_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__contrib_ifft(ndarray)" =
-     '[]
-
-_backward__contrib_ifft ::
-                        forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args =>
-                          ArgsHMap "_backward__contrib_ifft(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward__contrib_ifft args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_ifft_upd ::
-                            forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward__contrib_ifft(ndarray)" args -> IO ()
-_backward__contrib_ifft_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__Native(ndarray)" = '[]
-
-_backward__Native ::
-                  forall args . Fullfilled "_backward__Native(ndarray)" args =>
-                    ArgsHMap "_backward__Native(ndarray)" args -> IO [NDArrayHandle]
-_backward__Native args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__Native"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__Native_upd ::
-                      forall args . Fullfilled "_backward__Native(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward__Native(ndarray)" args -> IO ()
-_backward__Native_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__Native"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__NDArray(ndarray)" = '[]
-
-_backward__NDArray ::
-                   forall args . Fullfilled "_backward__NDArray(ndarray)" args =>
-                     ArgsHMap "_backward__NDArray(ndarray)" args -> IO [NDArrayHandle]
-_backward__NDArray args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__NDArray"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__NDArray_upd ::
-                       forall args . Fullfilled "_backward__NDArray(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward__NDArray(ndarray)" args -> IO ()
-_backward__NDArray_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__NDArray"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_InstanceNorm(ndarray)" =
-     '[ '("eps", AttrOpt Float), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_InstanceNorm ::
-              forall args . Fullfilled "_InstanceNorm(ndarray)" args =>
-                ArgsHMap "_InstanceNorm(ndarray)" args -> IO [NDArrayHandle]
-_InstanceNorm args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_InstanceNorm_upd ::
-                  forall args . Fullfilled "_InstanceNorm(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_InstanceNorm(ndarray)" args -> IO ()
-_InstanceNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_InstanceNorm(ndarray)" = '[]
-
-_backward_InstanceNorm ::
-                       forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args =>
-                         ArgsHMap "_backward_InstanceNorm(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_InstanceNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_InstanceNorm_upd ::
-                           forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_InstanceNorm(ndarray)" args -> IO ()
-_backward_InstanceNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SVMOutput(ndarray)" =
-     '[ '("margin", AttrOpt Float),
-        '("regularization_coefficient", AttrOpt Float),
-        '("use_linear", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_SVMOutput ::
-           forall args . Fullfilled "_SVMOutput(ndarray)" args =>
-             ArgsHMap "_SVMOutput(ndarray)" args -> IO [NDArrayHandle]
-_SVMOutput args
-  = let scalarArgs
-          = catMaybes
-              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),
-               ("regularization_coefficient",) . showValue <$>
-                 (args !? #regularization_coefficient :: Maybe Float),
-               ("use_linear",) . showValue <$>
-                 (args !? #use_linear :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SVMOutput_upd ::
-               forall args . Fullfilled "_SVMOutput(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_SVMOutput(ndarray)" args -> IO ()
-_SVMOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),
-               ("regularization_coefficient",) . showValue <$>
-                 (args !? #regularization_coefficient :: Maybe Float),
-               ("use_linear",) . showValue <$>
-                 (args !? #use_linear :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SVMOutput(ndarray)" = '[]
-
-_backward_SVMOutput ::
-                    forall args . Fullfilled "_backward_SVMOutput(ndarray)" args =>
-                      ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO [NDArrayHandle]
-_backward_SVMOutput args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SVMOutput_upd ::
-                        forall args . Fullfilled "_backward_SVMOutput(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO ()
-_backward_SVMOutput_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Pooling(ndarray)" =
-     '[ '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
-        '("kernel", AttrReq [Int]),
-        '("pool_type", AttrReq (EnumType '["avg", "max", "sum"])),
-        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Pooling ::
-         forall args . Fullfilled "_Pooling(ndarray)" args =>
-           ArgsHMap "_Pooling(ndarray)" args -> IO [NDArrayHandle]
-_Pooling args
-  = let scalarArgs
-          = catMaybes
-              [("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Pooling_upd ::
-             forall args . Fullfilled "_Pooling(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Pooling(ndarray)" args -> IO ()
-_Pooling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Pooling(ndarray)" = '[]
-
-_backward_Pooling ::
-                  forall args . Fullfilled "_backward_Pooling(ndarray)" args =>
-                    ArgsHMap "_backward_Pooling(ndarray)" args -> IO [NDArrayHandle]
-_backward_Pooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Pooling_upd ::
-                      forall args . Fullfilled "_backward_Pooling(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_Pooling(ndarray)" args -> IO ()
-_backward_Pooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Convolution_v1(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_Convolution_v1 ::
-                forall args . Fullfilled "_Convolution_v1(ndarray)" args =>
-                  ArgsHMap "_Convolution_v1(ndarray)" args -> IO [NDArrayHandle]
-_Convolution_v1 args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Convolution_v1_upd ::
-                    forall args . Fullfilled "_Convolution_v1(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_Convolution_v1(ndarray)" args -> IO ()
-_Convolution_v1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Convolution_v1(ndarray)" =
-     '[]
-
-_backward_Convolution_v1 ::
-                         forall args .
-                           Fullfilled "_backward_Convolution_v1(ndarray)" args =>
-                           ArgsHMap "_backward_Convolution_v1(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_Convolution_v1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Convolution_v1_upd ::
-                             forall args .
-                               Fullfilled "_backward_Convolution_v1(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_Convolution_v1(ndarray)" args -> IO ()
-_backward_Convolution_v1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Crop(ndarray)" =
-     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),
-        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_Crop ::
-      forall args . Fullfilled "_Crop(ndarray)" args =>
-        ArgsHMap "_Crop(ndarray)" args -> IO [NDArrayHandle]
-_Crop args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),
-               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),
-               ("center_crop",) . showValue <$>
-                 (args !? #center_crop :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Crop"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_Crop_upd ::
-          forall args . Fullfilled "_Crop(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_Crop(ndarray)" args -> IO ()
-_Crop_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),
-               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),
-               ("center_crop",) . showValue <$>
-                 (args !? #center_crop :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Crop"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Crop(ndarray)" = '[]
-
-_backward_Crop ::
-               forall args . Fullfilled "_backward_Crop(ndarray)" args =>
-                 ArgsHMap "_backward_Crop(ndarray)" args -> IO [NDArrayHandle]
-_backward_Crop args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Crop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Crop_upd ::
-                   forall args . Fullfilled "_backward_Crop(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_Crop(ndarray)" args -> IO ()
-_backward_Crop_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Crop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SpatialTransformer(ndarray)" =
-     '[ '("target_shape", AttrOpt [Int]),
-        '("transform_type", AttrReq (EnumType '["affine"])),
-        '("sampler_type", AttrReq (EnumType '["bilinear"])),
-        '("data", AttrOpt NDArrayHandle), '("loc", AttrOpt NDArrayHandle)]
-
-_SpatialTransformer ::
-                    forall args . Fullfilled "_SpatialTransformer(ndarray)" args =>
-                      ArgsHMap "_SpatialTransformer(ndarray)" args -> IO [NDArrayHandle]
-_SpatialTransformer args
-  = let scalarArgs
-          = catMaybes
-              [("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine"])),
-               ("sampler_type",) . showValue <$>
-                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SpatialTransformer_upd ::
-                        forall args . Fullfilled "_SpatialTransformer(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_SpatialTransformer(ndarray)" args -> IO ()
-_SpatialTransformer_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine"])),
-               ("sampler_type",) . showValue <$>
-                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SpatialTransformer(ndarray)"
-     = '[]
-
-_backward_SpatialTransformer ::
-                             forall args .
-                               Fullfilled "_backward_SpatialTransformer(ndarray)" args =>
-                               ArgsHMap "_backward_SpatialTransformer(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_backward_SpatialTransformer args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SpatialTransformer_upd ::
-                                 forall args .
-                                   Fullfilled "_backward_SpatialTransformer(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> IO ()
-_backward_SpatialTransformer_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SwapAxis(ndarray)" = '[]
-
-_backward_SwapAxis ::
-                   forall args . Fullfilled "_backward_SwapAxis(ndarray)" args =>
-                     ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO [NDArrayHandle]
-_backward_SwapAxis args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SwapAxis_upd ::
-                       forall args . Fullfilled "_backward_SwapAxis(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO ()
-_backward_SwapAxis_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LinearRegressionOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_LinearRegressionOutput ::
-                        forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args =>
-                          ArgsHMap "_LinearRegressionOutput(ndarray)" args ->
-                            IO [NDArrayHandle]
-_LinearRegressionOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LinearRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LinearRegressionOutput_upd ::
-                            forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_LinearRegressionOutput(ndarray)" args -> IO ()
-_LinearRegressionOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LinearRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_LinearRegressionOutput(ndarray)" = '[]
-
-_backward_LinearRegressionOutput ::
-                                 forall args .
-                                   Fullfilled "_backward_LinearRegressionOutput(ndarray)" args =>
-                                   ArgsHMap "_backward_LinearRegressionOutput(ndarray)" args ->
-                                     IO [NDArrayHandle]
-_backward_LinearRegressionOutput args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LinearRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_LinearRegressionOutput_upd ::
-                                     forall args .
-                                       Fullfilled "_backward_LinearRegressionOutput(ndarray)"
-                                         args =>
-                                       [NDArrayHandle] ->
-                                         ArgsHMap "_backward_LinearRegressionOutput(ndarray)" args
-                                           -> IO ()
-_backward_LinearRegressionOutput_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LinearRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_MAERegressionOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_MAERegressionOutput ::
-                     forall args . Fullfilled "_MAERegressionOutput(ndarray)" args =>
-                       ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO [NDArrayHandle]
-_MAERegressionOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MAERegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_MAERegressionOutput_upd ::
-                         forall args . Fullfilled "_MAERegressionOutput(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO ()
-_MAERegressionOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MAERegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_MAERegressionOutput(ndarray)" = '[]
-
-_backward_MAERegressionOutput ::
-                              forall args .
-                                Fullfilled "_backward_MAERegressionOutput(ndarray)" args =>
-                                ArgsHMap "_backward_MAERegressionOutput(ndarray)" args ->
-                                  IO [NDArrayHandle]
-_backward_MAERegressionOutput args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MAERegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_MAERegressionOutput_upd ::
-                                  forall args .
-                                    Fullfilled "_backward_MAERegressionOutput(ndarray)" args =>
-                                    [NDArrayHandle] ->
-                                      ArgsHMap "_backward_MAERegressionOutput(ndarray)" args ->
-                                        IO ()
-_backward_MAERegressionOutput_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MAERegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LogisticRegressionOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_LogisticRegressionOutput ::
-                          forall args .
-                            Fullfilled "_LogisticRegressionOutput(ndarray)" args =>
-                            ArgsHMap "_LogisticRegressionOutput(ndarray)" args ->
-                              IO [NDArrayHandle]
-_LogisticRegressionOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LogisticRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LogisticRegressionOutput_upd ::
-                              forall args .
-                                Fullfilled "_LogisticRegressionOutput(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> IO ()
-_LogisticRegressionOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LogisticRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_LogisticRegressionOutput(ndarray)" = '[]
-
-_backward_LogisticRegressionOutput ::
-                                   forall args .
-                                     Fullfilled "_backward_LogisticRegressionOutput(ndarray)"
-                                       args =>
-                                     ArgsHMap "_backward_LogisticRegressionOutput(ndarray)" args ->
-                                       IO [NDArrayHandle]
-_backward_LogisticRegressionOutput args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LogisticRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_LogisticRegressionOutput_upd ::
-                                       forall args .
-                                         Fullfilled "_backward_LogisticRegressionOutput(ndarray)"
-                                           args =>
-                                         [NDArrayHandle] ->
-                                           ArgsHMap "_backward_LogisticRegressionOutput(ndarray)"
-                                             args
-                                             -> IO ()
-_backward_LogisticRegressionOutput_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LogisticRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Pad(ndarray)" = '[]
-
-_backward_Pad ::
-              forall args . Fullfilled "_backward_Pad(ndarray)" args =>
-                ArgsHMap "_backward_Pad(ndarray)" args -> IO [NDArrayHandle]
-_backward_Pad args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Pad_upd ::
-                  forall args . Fullfilled "_backward_Pad(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_Pad(ndarray)" args -> IO ()
-_backward_Pad_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SoftmaxOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
-        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_SoftmaxOutput ::
-               forall args . Fullfilled "_SoftmaxOutput(ndarray)" args =>
-                 ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO [NDArrayHandle]
-_SoftmaxOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SoftmaxOutput_upd ::
-                   forall args . Fullfilled "_SoftmaxOutput(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO ()
-_SoftmaxOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SoftmaxOutput(ndarray)" =
-     '[]
-
-_backward_SoftmaxOutput ::
-                        forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args =>
-                          ArgsHMap "_backward_SoftmaxOutput(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_SoftmaxOutput args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SoftmaxOutput_upd ::
-                            forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> IO ()
-_backward_SoftmaxOutput_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Softmax(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
-        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Softmax ::
-         forall args . Fullfilled "_Softmax(ndarray)" args =>
-           ArgsHMap "_Softmax(ndarray)" args -> IO [NDArrayHandle]
-_Softmax args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Softmax_upd ::
-             forall args . Fullfilled "_Softmax(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Softmax(ndarray)" args -> IO ()
-_Softmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Softmax(ndarray)" = '[]
-
-_backward_Softmax ::
-                  forall args . Fullfilled "_backward_Softmax(ndarray)" args =>
-                    ArgsHMap "_backward_Softmax(ndarray)" args -> IO [NDArrayHandle]
-_backward_Softmax args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Softmax_upd ::
-                      forall args . Fullfilled "_backward_Softmax(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_Softmax(ndarray)" args -> IO ()
-_backward_Softmax_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SequenceReverse(ndarray)" =
-     '[ '("use_sequence_length", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle),
-        '("sequence_length", AttrOpt NDArrayHandle)]
-
-_SequenceReverse ::
-                 forall args . Fullfilled "_SequenceReverse(ndarray)" args =>
-                   ArgsHMap "_SequenceReverse(ndarray)" args -> IO [NDArrayHandle]
-_SequenceReverse args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SequenceReverse_upd ::
-                     forall args . Fullfilled "_SequenceReverse(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_SequenceReverse(ndarray)" args -> IO ()
-_SequenceReverse_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SequenceReverse(ndarray)" =
-     '[]
-
-_backward_SequenceReverse ::
-                          forall args .
-                            Fullfilled "_backward_SequenceReverse(ndarray)" args =>
-                            ArgsHMap "_backward_SequenceReverse(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_SequenceReverse args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SequenceReverse_upd ::
-                              forall args .
-                                Fullfilled "_backward_SequenceReverse(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_SequenceReverse(ndarray)" args -> IO ()
-_backward_SequenceReverse_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_BatchNorm_v1(ndarray)" = '[]
-
-_backward_BatchNorm_v1 ::
-                       forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args =>
-                         ArgsHMap "_backward_BatchNorm_v1(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_BatchNorm_v1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_BatchNorm_v1_upd ::
-                           forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> IO ()
-_backward_BatchNorm_v1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SequenceLast(ndarray)" =
-     '[ '("use_sequence_length", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle),
-        '("sequence_length", AttrOpt NDArrayHandle)]
-
-_SequenceLast ::
-              forall args . Fullfilled "_SequenceLast(ndarray)" args =>
-                ArgsHMap "_SequenceLast(ndarray)" args -> IO [NDArrayHandle]
-_SequenceLast args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SequenceLast_upd ::
-                  forall args . Fullfilled "_SequenceLast(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_SequenceLast(ndarray)" args -> IO ()
-_SequenceLast_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SequenceLast(ndarray)" = '[]
-
-_backward_SequenceLast ::
-                       forall args . Fullfilled "_backward_SequenceLast(ndarray)" args =>
-                         ArgsHMap "_backward_SequenceLast(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_SequenceLast args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SequenceLast_upd ::
-                           forall args . Fullfilled "_backward_SequenceLast(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_SequenceLast(ndarray)" args -> IO ()
-_backward_SequenceLast_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Correlation(ndarray)" =
-     '[ '("kernel_size", AttrOpt Int),
-        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),
-        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),
-        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt NDArrayHandle),
-        '("data2", AttrOpt NDArrayHandle)]
-
-_Correlation ::
-             forall args . Fullfilled "_Correlation(ndarray)" args =>
-               ArgsHMap "_Correlation(ndarray)" args -> IO [NDArrayHandle]
-_Correlation args
-  = let scalarArgs
-          = catMaybes
-              [("kernel_size",) . showValue <$>
-                 (args !? #kernel_size :: Maybe Int),
-               ("max_displacement",) . showValue <$>
-                 (args !? #max_displacement :: Maybe Int),
-               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),
-               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),
-               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),
-               ("is_multiply",) . showValue <$>
-                 (args !? #is_multiply :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle),
-               ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Correlation_upd ::
-                 forall args . Fullfilled "_Correlation(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_Correlation(ndarray)" args -> IO ()
-_Correlation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel_size",) . showValue <$>
-                 (args !? #kernel_size :: Maybe Int),
-               ("max_displacement",) . showValue <$>
-                 (args !? #max_displacement :: Maybe Int),
-               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),
-               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),
-               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),
-               ("is_multiply",) . showValue <$>
-                 (args !? #is_multiply :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle),
-               ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Correlation(ndarray)" = '[]
-
-_backward_Correlation ::
-                      forall args . Fullfilled "_backward_Correlation(ndarray)" args =>
-                        ArgsHMap "_backward_Correlation(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_Correlation args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Correlation_upd ::
-                          forall args . Fullfilled "_backward_Correlation(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_Correlation(ndarray)" args -> IO ()
-_backward_Correlation_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_MakeLoss(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_MakeLoss ::
-          forall args . Fullfilled "_MakeLoss(ndarray)" args =>
-            ArgsHMap "_MakeLoss(ndarray)" args -> IO [NDArrayHandle]
-_MakeLoss args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_MakeLoss_upd ::
-              forall args . Fullfilled "_MakeLoss(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_MakeLoss(ndarray)" args -> IO ()
-_MakeLoss_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_MakeLoss(ndarray)" = '[]
-
-_backward_MakeLoss ::
-                   forall args . Fullfilled "_backward_MakeLoss(ndarray)" args =>
-                     ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO [NDArrayHandle]
-_backward_MakeLoss args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_MakeLoss_upd ::
-                       forall args . Fullfilled "_backward_MakeLoss(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO ()
-_backward_MakeLoss_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LRN(ndarray)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_LRN ::
-     forall args . Fullfilled "_LRN(ndarray)" args =>
-       ArgsHMap "_LRN(ndarray)" args -> IO [NDArrayHandle]
-_LRN args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),
-               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LRN_upd ::
-         forall args . Fullfilled "_LRN(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_LRN(ndarray)" args -> IO ()
-_LRN_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),
-               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_LRN(ndarray)" = '[]
-
-_backward_LRN ::
-              forall args . Fullfilled "_backward_LRN(ndarray)" args =>
-                ArgsHMap "_backward_LRN(ndarray)" args -> IO [NDArrayHandle]
-_backward_LRN args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_LRN_upd ::
-                  forall args . Fullfilled "_backward_LRN(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_LRN(ndarray)" args -> IO ()
-_backward_LRN_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SequenceMask(ndarray)" =
-     '[ '("use_sequence_length", AttrOpt Bool),
-        '("value", AttrOpt Float), '("data", AttrOpt NDArrayHandle),
-        '("sequence_length", AttrOpt NDArrayHandle)]
-
-_SequenceMask ::
-              forall args . Fullfilled "_SequenceMask(ndarray)" args =>
-                ArgsHMap "_SequenceMask(ndarray)" args -> IO [NDArrayHandle]
-_SequenceMask args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("value",) . showValue <$> (args !? #value :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SequenceMask_upd ::
-                  forall args . Fullfilled "_SequenceMask(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_SequenceMask(ndarray)" args -> IO ()
-_SequenceMask_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("value",) . showValue <$> (args !? #value :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SequenceMask(ndarray)" = '[]
-
-_backward_SequenceMask ::
-                       forall args . Fullfilled "_backward_SequenceMask(ndarray)" args =>
-                         ArgsHMap "_backward_SequenceMask(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_SequenceMask args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SequenceMask_upd ::
-                           forall args . Fullfilled "_backward_SequenceMask(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_SequenceMask(ndarray)" args -> IO ()
-_backward_SequenceMask_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_GridGenerator(ndarray)" =
-     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),
-        '("target_shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-_GridGenerator ::
-               forall args . Fullfilled "_GridGenerator(ndarray)" args =>
-                 ArgsHMap "_GridGenerator(ndarray)" args -> IO [NDArrayHandle]
-_GridGenerator args
-  = let scalarArgs
-          = catMaybes
-              [("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_GridGenerator_upd ::
-                   forall args . Fullfilled "_GridGenerator(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_GridGenerator(ndarray)" args -> IO ()
-_GridGenerator_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_GridGenerator(ndarray)" =
-     '[]
-
-_backward_GridGenerator ::
-                        forall args . Fullfilled "_backward_GridGenerator(ndarray)" args =>
-                          ArgsHMap "_backward_GridGenerator(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_GridGenerator args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_GridGenerator_upd ::
-                            forall args . Fullfilled "_backward_GridGenerator(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_GridGenerator(ndarray)" args -> IO ()
-_backward_GridGenerator_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Pooling_v1(ndarray)" =
-     '[ '("global_pool", AttrOpt Bool), '("kernel", AttrReq [Int]),
-        '("pool_type", AttrReq (EnumType '["avg", "max", "sum"])),
-        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Pooling_v1 ::
-            forall args . Fullfilled "_Pooling_v1(ndarray)" args =>
-              ArgsHMap "_Pooling_v1(ndarray)" args -> IO [NDArrayHandle]
-_Pooling_v1 args
-  = let scalarArgs
-          = catMaybes
-              [("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Pooling_v1_upd ::
-                forall args . Fullfilled "_Pooling_v1(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_Pooling_v1(ndarray)" args -> IO ()
-_Pooling_v1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Pooling_v1(ndarray)" = '[]
-
-_backward_Pooling_v1 ::
-                     forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args =>
-                       ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO [NDArrayHandle]
-_backward_Pooling_v1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Pooling_v1_upd ::
-                         forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO ()
-_backward_Pooling_v1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_LeakyReLU(ndarray)" = '[]
-
-_backward_LeakyReLU ::
-                    forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args =>
-                      ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO [NDArrayHandle]
-_backward_LeakyReLU args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_LeakyReLU_upd ::
-                        forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO ()
-_backward_LeakyReLU_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_IdentityAttachKLSparseReg(ndarray)" = '[]
-
-_backward_IdentityAttachKLSparseReg ::
-                                    forall args .
-                                      Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)"
-                                        args =>
-                                      ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" args
-                                        -> IO [NDArrayHandle]
-_backward_IdentityAttachKLSparseReg args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_IdentityAttachKLSparseReg_upd ::
-                                        forall args .
-                                          Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)"
-                                            args =>
-                                          [NDArrayHandle] ->
-                                            ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)"
-                                              args
-                                              -> IO ()
-_backward_IdentityAttachKLSparseReg_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Activation(ndarray)" =
-     '[ '("act_type",
-          AttrReq (EnumType '["relu", "sigmoid", "softrelu", "tanh"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Activation ::
-            forall args . Fullfilled "_Activation(ndarray)" args =>
-              ArgsHMap "_Activation(ndarray)" args -> IO [NDArrayHandle]
-_Activation args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe (EnumType '["relu", "sigmoid", "softrelu", "tanh"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Activation_upd ::
-                forall args . Fullfilled "_Activation(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_Activation(ndarray)" args -> IO ()
-_Activation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe (EnumType '["relu", "sigmoid", "softrelu", "tanh"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Activation(ndarray)" = '[]
-
-_backward_Activation ::
-                     forall args . Fullfilled "_backward_Activation(ndarray)" args =>
-                       ArgsHMap "_backward_Activation(ndarray)" args -> IO [NDArrayHandle]
-_backward_Activation args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Activation_upd ::
-                         forall args . Fullfilled "_backward_Activation(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_Activation(ndarray)" args -> IO ()
-_backward_Activation_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_UpSampling(ndarray)" = '[]
-
-_backward_UpSampling ::
-                     forall args . Fullfilled "_backward_UpSampling(ndarray)" args =>
-                       ArgsHMap "_backward_UpSampling(ndarray)" args -> IO [NDArrayHandle]
-_backward_UpSampling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_UpSampling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_UpSampling_upd ::
-                         forall args . Fullfilled "_backward_UpSampling(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_UpSampling(ndarray)" args -> IO ()
-_backward_UpSampling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_UpSampling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Deconvolution(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_Deconvolution ::
-               forall args . Fullfilled "_Deconvolution(ndarray)" args =>
-                 ArgsHMap "_Deconvolution(ndarray)" args -> IO [NDArrayHandle]
-_Deconvolution args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Deconvolution_upd ::
-                   forall args . Fullfilled "_Deconvolution(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_Deconvolution(ndarray)" args -> IO ()
-_Deconvolution_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Deconvolution(ndarray)" =
-     '[]
-
-_backward_Deconvolution ::
-                        forall args . Fullfilled "_backward_Deconvolution(ndarray)" args =>
-                          ArgsHMap "_backward_Deconvolution(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_Deconvolution args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Deconvolution_upd ::
-                            forall args . Fullfilled "_backward_Deconvolution(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_Deconvolution(ndarray)" args -> IO ()
-_backward_Deconvolution_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BilinearSampler(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("grid", AttrOpt NDArrayHandle)]
-
-_BilinearSampler ::
-                 forall args . Fullfilled "_BilinearSampler(ndarray)" args =>
-                   ArgsHMap "_BilinearSampler(ndarray)" args -> IO [NDArrayHandle]
-_BilinearSampler args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BilinearSampler_upd ::
-                     forall args . Fullfilled "_BilinearSampler(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_BilinearSampler(ndarray)" args -> IO ()
-_BilinearSampler_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_BilinearSampler(ndarray)" =
-     '[]
-
-_backward_BilinearSampler ::
-                          forall args .
-                            Fullfilled "_backward_BilinearSampler(ndarray)" args =>
-                            ArgsHMap "_backward_BilinearSampler(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_BilinearSampler args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_BilinearSampler_upd ::
-                              forall args .
-                                Fullfilled "_backward_BilinearSampler(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_BilinearSampler(ndarray)" args -> IO ()
-_backward_BilinearSampler_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_ROIPooling(ndarray)" =
-     '[ '("pooled_size", AttrReq [Int]),
-        '("spatial_scale", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)]
-
-_ROIPooling ::
-            forall args . Fullfilled "_ROIPooling(ndarray)" args =>
-              ArgsHMap "_ROIPooling(ndarray)" args -> IO [NDArrayHandle]
-_ROIPooling args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_ROIPooling_upd ::
-                forall args . Fullfilled "_ROIPooling(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_ROIPooling(ndarray)" args -> IO ()
-_ROIPooling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_ROIPooling(ndarray)" = '[]
-
-_backward_ROIPooling ::
-                     forall args . Fullfilled "_backward_ROIPooling(ndarray)" args =>
-                       ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO [NDArrayHandle]
-_backward_ROIPooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_ROIPooling_upd ::
-                         forall args . Fullfilled "_backward_ROIPooling(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO ()
-_backward_ROIPooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SliceChannel(ndarray)" = '[]
-
-_backward_SliceChannel ::
-                       forall args . Fullfilled "_backward_SliceChannel(ndarray)" args =>
-                         ArgsHMap "_backward_SliceChannel(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_SliceChannel args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SliceChannel_upd ::
-                           forall args . Fullfilled "_backward_SliceChannel(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_SliceChannel(ndarray)" args -> IO ()
-_backward_SliceChannel_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_CuDNNBatchNorm(ndarray)" =
-     '[]
-
-_backward_CuDNNBatchNorm ::
-                         forall args .
-                           Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args =>
-                           ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_CuDNNBatchNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_CuDNNBatchNorm_upd ::
-                             forall args .
-                               Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args -> IO ()
-_backward_CuDNNBatchNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_FullyConnected(ndarray)" =
-     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
-        '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_FullyConnected ::
-                forall args . Fullfilled "_FullyConnected(ndarray)" args =>
-                  ArgsHMap "_FullyConnected(ndarray)" args -> IO [NDArrayHandle]
-_FullyConnected args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_FullyConnected_upd ::
-                    forall args . Fullfilled "_FullyConnected(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_FullyConnected(ndarray)" args -> IO ()
-_FullyConnected_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_FullyConnected(ndarray)" =
-     '[]
-
-_backward_FullyConnected ::
-                         forall args .
-                           Fullfilled "_backward_FullyConnected(ndarray)" args =>
-                           ArgsHMap "_backward_FullyConnected(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_FullyConnected args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_FullyConnected_upd ::
-                             forall args .
-                               Fullfilled "_backward_FullyConnected(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_FullyConnected(ndarray)" args -> IO ()
-_backward_FullyConnected_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Convolution(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_Convolution ::
-             forall args . Fullfilled "_Convolution(ndarray)" args =>
-               ArgsHMap "_Convolution(ndarray)" args -> IO [NDArrayHandle]
-_Convolution args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Convolution_upd ::
-                 forall args . Fullfilled "_Convolution(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_Convolution(ndarray)" args -> IO ()
-_Convolution_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Convolution(ndarray)" = '[]
-
-_backward_Convolution ::
-                      forall args . Fullfilled "_backward_Convolution(ndarray)" args =>
-                        ArgsHMap "_backward_Convolution(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_Convolution args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Convolution_upd ::
-                          forall args . Fullfilled "_backward_Convolution(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_Convolution(ndarray)" args -> IO ()
-_backward_Convolution_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_L2Normalization(ndarray)" =
-     '[ '("eps", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_L2Normalization ::
-                 forall args . Fullfilled "_L2Normalization(ndarray)" args =>
-                   ArgsHMap "_L2Normalization(ndarray)" args -> IO [NDArrayHandle]
-_L2Normalization args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["channel", "instance", "spatial"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_L2Normalization_upd ::
-                     forall args . Fullfilled "_L2Normalization(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_L2Normalization(ndarray)" args -> IO ()
-_L2Normalization_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["channel", "instance", "spatial"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_L2Normalization(ndarray)" =
-     '[]
-
-_backward_L2Normalization ::
-                          forall args .
-                            Fullfilled "_backward_L2Normalization(ndarray)" args =>
-                            ArgsHMap "_backward_L2Normalization(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_L2Normalization args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_L2Normalization_upd ::
-                              forall args .
-                                Fullfilled "_backward_L2Normalization(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_L2Normalization(ndarray)" args -> IO ()
-_backward_L2Normalization_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Concat(ndarray)" = '[]
-
-_backward_Concat ::
-                 forall args . Fullfilled "_backward_Concat(ndarray)" args =>
-                   ArgsHMap "_backward_Concat(ndarray)" args -> IO [NDArrayHandle]
-_backward_Concat args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Concat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Concat_upd ::
-                     forall args . Fullfilled "_backward_Concat(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_Concat(ndarray)" args -> IO ()
-_backward_Concat_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Concat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_RNN(ndarray)" =
-     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),
-        '("bidirectional", AttrOpt Bool),
-        '("mode",
-          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle),
-        '("parameters", AttrOpt NDArrayHandle),
-        '("state", AttrOpt NDArrayHandle),
-        '("state_cell", AttrOpt NDArrayHandle)]
-
-_RNN ::
-     forall args . Fullfilled "_RNN(ndarray)" args =>
-       ArgsHMap "_RNN(ndarray)" args -> IO [NDArrayHandle]
-_RNN args
-  = let scalarArgs
-          = catMaybes
-              [("state_size",) . showValue <$>
-                 (args !? #state_size :: Maybe Int),
-               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),
-               ("bidirectional",) . showValue <$>
-                 (args !? #bidirectional :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("state_outputs",) . showValue <$>
-                 (args !? #state_outputs :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle),
-               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),
-               ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_RNN_upd ::
-         forall args . Fullfilled "_RNN(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_RNN(ndarray)" args -> IO ()
-_RNN_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("state_size",) . showValue <$>
-                 (args !? #state_size :: Maybe Int),
-               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),
-               ("bidirectional",) . showValue <$>
-                 (args !? #bidirectional :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("state_outputs",) . showValue <$>
-                 (args !? #state_outputs :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle),
-               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),
-               ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_RNN(ndarray)" = '[]
-
-_backward_RNN ::
-              forall args . Fullfilled "_backward_RNN(ndarray)" args =>
-                ArgsHMap "_backward_RNN(ndarray)" args -> IO [NDArrayHandle]
-_backward_RNN args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_RNN_upd ::
-                  forall args . Fullfilled "_backward_RNN(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_RNN(ndarray)" args -> IO ()
-_backward_RNN_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_BatchNorm(ndarray)" = '[]
-
-_backward_BatchNorm ::
-                    forall args . Fullfilled "_backward_BatchNorm(ndarray)" args =>
-                      ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO [NDArrayHandle]
-_backward_BatchNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_BatchNorm_upd ::
-                        forall args . Fullfilled "_backward_BatchNorm(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO ()
-_backward_BatchNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Dropout(ndarray)" =
-     '[ '("p", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["always", "training"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Dropout ::
-         forall args . Fullfilled "_Dropout(ndarray)" args =>
-           ArgsHMap "_Dropout(ndarray)" args -> IO [NDArrayHandle]
-_Dropout args
-  = let scalarArgs
-          = catMaybes
-              [("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["always", "training"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Dropout_upd ::
-             forall args . Fullfilled "_Dropout(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Dropout(ndarray)" args -> IO ()
-_Dropout_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["always", "training"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Dropout(ndarray)" = '[]
-
-_backward_Dropout ::
-                  forall args . Fullfilled "_backward_Dropout(ndarray)" args =>
-                    ArgsHMap "_backward_Dropout(ndarray)" args -> IO [NDArrayHandle]
-_backward_Dropout args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Dropout_upd ::
-                      forall args . Fullfilled "_backward_Dropout(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_Dropout(ndarray)" args -> IO ()
-_backward_Dropout_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CrossDeviceCopy(ndarray)" = '[]
-
-_CrossDeviceCopy ::
-                 forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args =>
-                   ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO [NDArrayHandle]
-_CrossDeviceCopy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CrossDeviceCopy_upd ::
-                     forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO ()
-_CrossDeviceCopy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__CrossDeviceCopy(ndarray)" =
-     '[]
-
-_backward__CrossDeviceCopy ::
-                           forall args .
-                             Fullfilled "_backward__CrossDeviceCopy(ndarray)" args =>
-                             ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args ->
-                               IO [NDArrayHandle]
-_backward__CrossDeviceCopy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__CrossDeviceCopy_upd ::
-                               forall args .
-                                 Fullfilled "_backward__CrossDeviceCopy(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> IO ()
-_backward__CrossDeviceCopy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SoftmaxActivation(ndarray)" =
-     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_SoftmaxActivation ::
-                   forall args . Fullfilled "_SoftmaxActivation(ndarray)" args =>
-                     ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO [NDArrayHandle]
-_SoftmaxActivation args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SoftmaxActivation_upd ::
-                       forall args . Fullfilled "_SoftmaxActivation(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO ()
-_SoftmaxActivation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SoftmaxActivation(ndarray)"
-     = '[]
-
-_backward_SoftmaxActivation ::
-                            forall args .
-                              Fullfilled "_backward_SoftmaxActivation(ndarray)" args =>
-                              ArgsHMap "_backward_SoftmaxActivation(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_SoftmaxActivation args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SoftmaxActivation_upd ::
-                                forall args .
-                                  Fullfilled "_backward_SoftmaxActivation(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> IO ()
-_backward_SoftmaxActivation_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_set_value(ndarray)" =
-     '[ '("src", AttrOpt Float)]
-
-_set_value ::
-           forall args . Fullfilled "_set_value(ndarray)" args =>
-             ArgsHMap "_set_value(ndarray)" args -> IO [NDArrayHandle]
-_set_value args
-  = let scalarArgs
-          = catMaybes
-              [("src",) . showValue <$> (args !? #src :: Maybe Float)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_set_value"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_set_value_upd ::
-               forall args . Fullfilled "_set_value(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_set_value(ndarray)" args -> IO ()
-_set_value_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("src",) . showValue <$> (args !? #src :: Maybe Float)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_set_value"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_onehot_encode(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_onehot_encode ::
-               forall args . Fullfilled "_onehot_encode(ndarray)" args =>
-                 ArgsHMap "_onehot_encode(ndarray)" args -> IO [NDArrayHandle]
-_onehot_encode args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_onehot_encode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_onehot_encode_upd ::
-                   forall args . Fullfilled "_onehot_encode(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_onehot_encode(ndarray)" args -> IO ()
-_onehot_encode_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_onehot_encode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "choose_element_0index(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-choose_element_0index ::
-                      forall args . Fullfilled "choose_element_0index(ndarray)" args =>
-                        ArgsHMap "choose_element_0index(ndarray)" args ->
-                          IO [NDArrayHandle]
-choose_element_0index args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "choose_element_0index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-choose_element_0index_upd ::
-                          forall args . Fullfilled "choose_element_0index(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "choose_element_0index(ndarray)" args -> IO ()
-choose_element_0index_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "choose_element_0index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "fill_element_0index(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("mhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-fill_element_0index ::
-                    forall args . Fullfilled "fill_element_0index(ndarray)" args =>
-                      ArgsHMap "fill_element_0index(ndarray)" args -> IO [NDArrayHandle]
-fill_element_0index args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fill_element_0index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-fill_element_0index_upd ::
-                        forall args . Fullfilled "fill_element_0index(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "fill_element_0index(ndarray)" args -> IO ()
-fill_element_0index_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fill_element_0index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_imdecode(ndarray)" =
-     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),
-        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),
-        '("c", AttrOpt Int), '("size", AttrOpt Int),
-        '("mean", AttrOpt NDArrayHandle)]
-
-_imdecode ::
-          forall args . Fullfilled "_imdecode(ndarray)" args =>
-            ArgsHMap "_imdecode(ndarray)" args -> IO [NDArrayHandle]
-_imdecode args
-  = let scalarArgs
-          = catMaybes
-              [("index",) . showValue <$> (args !? #index :: Maybe Int),
-               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),
-               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),
-               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),
-               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),
-               ("c",) . showValue <$> (args !? #c :: Maybe Int),
-               ("size",) . showValue <$> (args !? #size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_imdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_imdecode_upd ::
-              forall args . Fullfilled "_imdecode(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_imdecode(ndarray)" args -> IO ()
-_imdecode_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("index",) . showValue <$> (args !? #index :: Maybe Int),
-               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),
-               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),
-               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),
-               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),
-               ("c",) . showValue <$> (args !? #c :: Maybe Int),
-               ("size",) . showValue <$> (args !? #size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_imdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
diff --git a/ops/1.0/MXNet/Base/Operators/Symbol.hs b/ops/1.0/MXNet/Base/Operators/Symbol.hs
deleted file mode 100644
--- a/ops/1.0/MXNet/Base/Operators/Symbol.hs
+++ /dev/null
@@ -1,9339 +0,0 @@
-module MXNet.Base.Operators.Symbol where
-import MXNet.Base.Raw
-import MXNet.Base.Spec.Operator
-import MXNet.Base.Spec.HMap
-import Data.Maybe (catMaybes, fromMaybe)
-
-type instance ParameterList "broadcast_power(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_power ::
-                forall args . Fullfilled "broadcast_power(symbol)" args =>
-                  String ->
-                    ArgsHMap "broadcast_power(symbol)" args -> IO SymbolHandle
-broadcast_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_power(symbol)" =
-     '[]
-
-_backward_broadcast_power ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_power(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_broadcast_power(symbol)" args ->
-                                IO SymbolHandle
-_backward_broadcast_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_maximum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_maximum ::
-                  forall args . Fullfilled "broadcast_maximum(symbol)" args =>
-                    String ->
-                      ArgsHMap "broadcast_maximum(symbol)" args -> IO SymbolHandle
-broadcast_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_maximum(symbol)" =
-     '[]
-
-_backward_broadcast_maximum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_maximum(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_broadcast_maximum(symbol)" args ->
-                                  IO SymbolHandle
-_backward_broadcast_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_minimum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_minimum ::
-                  forall args . Fullfilled "broadcast_minimum(symbol)" args =>
-                    String ->
-                      ArgsHMap "broadcast_minimum(symbol)" args -> IO SymbolHandle
-broadcast_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_minimum(symbol)" =
-     '[]
-
-_backward_broadcast_minimum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_minimum(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_broadcast_minimum(symbol)" args ->
-                                  IO SymbolHandle
-_backward_broadcast_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_hypot(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_hypot ::
-                forall args . Fullfilled "broadcast_hypot(symbol)" args =>
-                  String ->
-                    ArgsHMap "broadcast_hypot(symbol)" args -> IO SymbolHandle
-broadcast_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_hypot(symbol)" =
-     '[]
-
-_backward_broadcast_hypot ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_hypot(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_broadcast_hypot(symbol)" args ->
-                                IO SymbolHandle
-_backward_broadcast_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_equal ::
-       forall args . Fullfilled "_equal(symbol)" args =>
-         String -> ArgsHMap "_equal(symbol)" args -> IO SymbolHandle
-_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_not_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_not_equal ::
-           forall args . Fullfilled "_not_equal(symbol)" args =>
-             String -> ArgsHMap "_not_equal(symbol)" args -> IO SymbolHandle
-_not_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_greater ::
-         forall args . Fullfilled "_greater(symbol)" args =>
-           String -> ArgsHMap "_greater(symbol)" args -> IO SymbolHandle
-_greater name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_greater_equal ::
-               forall args . Fullfilled "_greater_equal(symbol)" args =>
-                 String -> ArgsHMap "_greater_equal(symbol)" args -> IO SymbolHandle
-_greater_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_lesser ::
-        forall args . Fullfilled "_lesser(symbol)" args =>
-          String -> ArgsHMap "_lesser(symbol)" args -> IO SymbolHandle
-_lesser name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_lesser_equal ::
-              forall args . Fullfilled "_lesser_equal(symbol)" args =>
-                String -> ArgsHMap "_lesser_equal(symbol)" args -> IO SymbolHandle
-_lesser_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_power(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_power ::
-       forall args . Fullfilled "_power(symbol)" args =>
-         String -> ArgsHMap "_power(symbol)" args -> IO SymbolHandle
-_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_power(symbol)" = '[]
-
-_backward_power ::
-                forall args . Fullfilled "_backward_power(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_power(symbol)" args -> IO SymbolHandle
-_backward_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_maximum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_maximum ::
-         forall args . Fullfilled "_maximum(symbol)" args =>
-           String -> ArgsHMap "_maximum(symbol)" args -> IO SymbolHandle
-_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_maximum(symbol)" = '[]
-
-_backward_maximum ::
-                  forall args . Fullfilled "_backward_maximum(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_maximum(symbol)" args -> IO SymbolHandle
-_backward_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_minimum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_minimum ::
-         forall args . Fullfilled "_minimum(symbol)" args =>
-           String -> ArgsHMap "_minimum(symbol)" args -> IO SymbolHandle
-_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_minimum(symbol)" = '[]
-
-_backward_minimum ::
-                  forall args . Fullfilled "_backward_minimum(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_minimum(symbol)" args -> IO SymbolHandle
-_backward_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_hypot(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_hypot ::
-       forall args . Fullfilled "_hypot(symbol)" args =>
-         String -> ArgsHMap "_hypot(symbol)" args -> IO SymbolHandle
-_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_hypot(symbol)" = '[]
-
-_backward_hypot ::
-                forall args . Fullfilled "_backward_hypot(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_hypot(symbol)" args -> IO SymbolHandle
-_backward_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_square_sum(symbol)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-_square_sum ::
-            forall args . Fullfilled "_square_sum(symbol)" args =>
-              String -> ArgsHMap "_square_sum(symbol)" args -> IO SymbolHandle
-_square_sum name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_square_sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_square_sum(symbol)" = '[]
-
-_backward_square_sum ::
-                     forall args . Fullfilled "_backward_square_sum(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_square_sum(symbol)" args -> IO SymbolHandle
-_backward_square_sum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square_sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "add_n(symbol)" =
-     '[ '("args", AttrOpt [SymbolHandle])]
-
-add_n ::
-      forall args . Fullfilled "add_n(symbol)" args =>
-        String -> ArgsHMap "add_n(symbol)" args -> IO SymbolHandle
-add_n name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "add_n"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_zeros(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-
-_zeros ::
-       forall args . Fullfilled "_zeros(symbol)" args =>
-         String -> ArgsHMap "_zeros(symbol)" args -> IO SymbolHandle
-_zeros name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_ones(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-
-_ones ::
-      forall args . Fullfilled "_ones(symbol)" args =>
-        String -> ArgsHMap "_ones(symbol)" args -> IO SymbolHandle
-_ones name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ones"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_full(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("value", AttrReq Double)]
-
-_full ::
-      forall args . Fullfilled "_full(symbol)" args =>
-        String -> ArgsHMap "_full(symbol)" args -> IO SymbolHandle
-_full name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_full"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_arange(symbol)" =
-     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),
-        '("step", AttrOpt Double), '("repeat", AttrOpt Int),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "uint8"]))]
-
-_arange ::
-        forall args . Fullfilled "_arange(symbol)" args =>
-          String -> ArgsHMap "_arange(symbol)" args -> IO SymbolHandle
-_arange name args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_arange"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "zeros_like(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-zeros_like ::
-           forall args . Fullfilled "zeros_like(symbol)" args =>
-             String -> ArgsHMap "zeros_like(symbol)" args -> IO SymbolHandle
-zeros_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "zeros_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ones_like(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-ones_like ::
-          forall args . Fullfilled "ones_like(symbol)" args =>
-            String -> ArgsHMap "ones_like(symbol)" args -> IO SymbolHandle
-ones_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ones_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_add(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_add ::
-              forall args . Fullfilled "broadcast_add(symbol)" args =>
-                String -> ArgsHMap "broadcast_add(symbol)" args -> IO SymbolHandle
-broadcast_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_add(symbol)" = '[]
-
-_backward_broadcast_add ::
-                        forall args . Fullfilled "_backward_broadcast_add(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_add(symbol)" args -> IO SymbolHandle
-_backward_broadcast_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_sub(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_sub ::
-              forall args . Fullfilled "broadcast_sub(symbol)" args =>
-                String -> ArgsHMap "broadcast_sub(symbol)" args -> IO SymbolHandle
-broadcast_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_sub(symbol)" = '[]
-
-_backward_broadcast_sub ::
-                        forall args . Fullfilled "_backward_broadcast_sub(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_sub(symbol)" args -> IO SymbolHandle
-_backward_broadcast_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_mul(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_mul ::
-              forall args . Fullfilled "broadcast_mul(symbol)" args =>
-                String -> ArgsHMap "broadcast_mul(symbol)" args -> IO SymbolHandle
-broadcast_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_mul(symbol)" = '[]
-
-_backward_broadcast_mul ::
-                        forall args . Fullfilled "_backward_broadcast_mul(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_mul(symbol)" args -> IO SymbolHandle
-_backward_broadcast_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_div(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_div ::
-              forall args . Fullfilled "broadcast_div(symbol)" args =>
-                String -> ArgsHMap "broadcast_div(symbol)" args -> IO SymbolHandle
-broadcast_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_div(symbol)" = '[]
-
-_backward_broadcast_div ::
-                        forall args . Fullfilled "_backward_broadcast_div(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_div(symbol)" args -> IO SymbolHandle
-_backward_broadcast_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_mod(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_mod ::
-              forall args . Fullfilled "broadcast_mod(symbol)" args =>
-                String -> ArgsHMap "broadcast_mod(symbol)" args -> IO SymbolHandle
-broadcast_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_mod(symbol)" = '[]
-
-_backward_broadcast_mod ::
-                        forall args . Fullfilled "_backward_broadcast_mod(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_mod(symbol)" args -> IO SymbolHandle
-_backward_broadcast_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_gemm(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),
-        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle),
-        '("_C", AttrOpt SymbolHandle)]
-
-_linalg_gemm ::
-             forall args . Fullfilled "_linalg_gemm(symbol)" args =>
-               String -> ArgsHMap "_linalg_gemm(symbol)" args -> IO SymbolHandle
-_linalg_gemm name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle),
-               ("_C",) <$> (args !? #_C :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_gemm(symbol)" = '[]
-
-_backward_linalg_gemm ::
-                      forall args . Fullfilled "_backward_linalg_gemm(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_gemm(symbol)" args -> IO SymbolHandle
-_backward_linalg_gemm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_gemm2(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle),
-        '("_B", AttrOpt SymbolHandle)]
-
-_linalg_gemm2 ::
-              forall args . Fullfilled "_linalg_gemm2(symbol)" args =>
-                String -> ArgsHMap "_linalg_gemm2(symbol)" args -> IO SymbolHandle
-_linalg_gemm2 name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_gemm2(symbol)" = '[]
-
-_backward_linalg_gemm2 ::
-                       forall args . Fullfilled "_backward_linalg_gemm2(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_gemm2(symbol)" args -> IO SymbolHandle
-_backward_linalg_gemm2 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_potrf(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_potrf ::
-              forall args . Fullfilled "_linalg_potrf(symbol)" args =>
-                String -> ArgsHMap "_linalg_potrf(symbol)" args -> IO SymbolHandle
-_linalg_potrf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potrf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_potrf(symbol)" = '[]
-
-_backward_linalg_potrf ::
-                       forall args . Fullfilled "_backward_linalg_potrf(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_potrf(symbol)" args -> IO SymbolHandle
-_backward_linalg_potrf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potrf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_potri(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_potri ::
-              forall args . Fullfilled "_linalg_potri(symbol)" args =>
-                String -> ArgsHMap "_linalg_potri(symbol)" args -> IO SymbolHandle
-_linalg_potri name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potri"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_potri(symbol)" = '[]
-
-_backward_linalg_potri ::
-                       forall args . Fullfilled "_backward_linalg_potri(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_potri(symbol)" args -> IO SymbolHandle
-_backward_linalg_potri name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potri"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_trmm(symbol)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle),
-        '("_B", AttrOpt SymbolHandle)]
-
-_linalg_trmm ::
-             forall args . Fullfilled "_linalg_trmm(symbol)" args =>
-               String -> ArgsHMap "_linalg_trmm(symbol)" args -> IO SymbolHandle
-_linalg_trmm name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trmm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_trmm(symbol)" = '[]
-
-_backward_linalg_trmm ::
-                      forall args . Fullfilled "_backward_linalg_trmm(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_trmm(symbol)" args -> IO SymbolHandle
-_backward_linalg_trmm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trmm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_trsm(symbol)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle),
-        '("_B", AttrOpt SymbolHandle)]
-
-_linalg_trsm ::
-             forall args . Fullfilled "_linalg_trsm(symbol)" args =>
-               String -> ArgsHMap "_linalg_trsm(symbol)" args -> IO SymbolHandle
-_linalg_trsm name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trsm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_trsm(symbol)" = '[]
-
-_backward_linalg_trsm ::
-                      forall args . Fullfilled "_backward_linalg_trsm(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_trsm(symbol)" args -> IO SymbolHandle
-_backward_linalg_trsm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trsm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_sumlogdiag(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_sumlogdiag ::
-                   forall args . Fullfilled "_linalg_sumlogdiag(symbol)" args =>
-                     String ->
-                       ArgsHMap "_linalg_sumlogdiag(symbol)" args -> IO SymbolHandle
-_linalg_sumlogdiag name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_sumlogdiag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_sumlogdiag(symbol)" =
-     '[]
-
-_backward_linalg_sumlogdiag ::
-                            forall args .
-                              Fullfilled "_backward_linalg_sumlogdiag(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_linalg_sumlogdiag(symbol)" args ->
-                                  IO SymbolHandle
-_backward_linalg_sumlogdiag name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_syrk(symbol)" =
-     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt SymbolHandle)]
-
-_linalg_syrk ::
-             forall args . Fullfilled "_linalg_syrk(symbol)" args =>
-               String -> ArgsHMap "_linalg_syrk(symbol)" args -> IO SymbolHandle
-_linalg_syrk name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syrk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_syrk(symbol)" = '[]
-
-_backward_linalg_syrk ::
-                      forall args . Fullfilled "_backward_linalg_syrk(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_syrk(symbol)" args -> IO SymbolHandle
-_backward_linalg_syrk name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syrk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_gelqf(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_gelqf ::
-              forall args . Fullfilled "_linalg_gelqf(symbol)" args =>
-                String -> ArgsHMap "_linalg_gelqf(symbol)" args -> IO SymbolHandle
-_linalg_gelqf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gelqf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_gelqf(symbol)" = '[]
-
-_backward_linalg_gelqf ::
-                       forall args . Fullfilled "_backward_linalg_gelqf(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_gelqf(symbol)" args -> IO SymbolHandle
-_backward_linalg_gelqf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gelqf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_syevd(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_syevd ::
-              forall args . Fullfilled "_linalg_syevd(symbol)" args =>
-                String -> ArgsHMap "_linalg_syevd(symbol)" args -> IO SymbolHandle
-_linalg_syevd name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syevd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_syevd(symbol)" = '[]
-
-_backward_linalg_syevd ::
-                       forall args . Fullfilled "_backward_linalg_syevd(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_syevd(symbol)" args -> IO SymbolHandle
-_backward_linalg_syevd name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syevd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cast_storage(symbol)" =
-     '[ '("stype",
-          AttrReq (EnumType '["csr", "default", "row_sparse"])),
-        '("data", AttrOpt SymbolHandle)]
-
-cast_storage ::
-             forall args . Fullfilled "cast_storage(symbol)" args =>
-               String -> ArgsHMap "cast_storage(symbol)" args -> IO SymbolHandle
-cast_storage name args
-  = let scalarArgs
-          = catMaybes
-              [("stype",) . showValue <$>
-                 (args !? #stype ::
-                    Maybe (EnumType '["csr", "default", "row_sparse"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cast_storage"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_equal_scalar ::
-              forall args . Fullfilled "_equal_scalar(symbol)" args =>
-                String -> ArgsHMap "_equal_scalar(symbol)" args -> IO SymbolHandle
-_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_not_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_not_equal_scalar ::
-                  forall args . Fullfilled "_not_equal_scalar(symbol)" args =>
-                    String ->
-                      ArgsHMap "_not_equal_scalar(symbol)" args -> IO SymbolHandle
-_not_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_greater_scalar ::
-                forall args . Fullfilled "_greater_scalar(symbol)" args =>
-                  String ->
-                    ArgsHMap "_greater_scalar(symbol)" args -> IO SymbolHandle
-_greater_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_greater_equal_scalar ::
-                      forall args . Fullfilled "_greater_equal_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_greater_equal_scalar(symbol)" args -> IO SymbolHandle
-_greater_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_lesser_scalar ::
-               forall args . Fullfilled "_lesser_scalar(symbol)" args =>
-                 String -> ArgsHMap "_lesser_scalar(symbol)" args -> IO SymbolHandle
-_lesser_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_lesser_equal_scalar ::
-                     forall args . Fullfilled "_lesser_equal_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_lesser_equal_scalar(symbol)" args -> IO SymbolHandle
-_lesser_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "relu(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-relu ::
-     forall args . Fullfilled "relu(symbol)" args =>
-       String -> ArgsHMap "relu(symbol)" args -> IO SymbolHandle
-relu name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "relu"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_relu(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_relu ::
-               forall args . Fullfilled "_backward_relu(symbol)" args =>
-                 String -> ArgsHMap "_backward_relu(symbol)" args -> IO SymbolHandle
-_backward_relu name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_relu"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sigmoid(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sigmoid ::
-        forall args . Fullfilled "sigmoid(symbol)" args =>
-          String -> ArgsHMap "sigmoid(symbol)" args -> IO SymbolHandle
-sigmoid name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sigmoid"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sigmoid(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sigmoid ::
-                  forall args . Fullfilled "_backward_sigmoid(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_sigmoid(symbol)" args -> IO SymbolHandle
-_backward_sigmoid name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sigmoid"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_copy(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_copy ::
-      forall args . Fullfilled "_copy(symbol)" args =>
-        String -> ArgsHMap "_copy(symbol)" args -> IO SymbolHandle
-_copy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_copy(symbol)" = '[]
-
-_backward_copy ::
-               forall args . Fullfilled "_backward_copy(symbol)" args =>
-                 String -> ArgsHMap "_backward_copy(symbol)" args -> IO SymbolHandle
-_backward_copy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_copy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BlockGrad(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_BlockGrad ::
-           forall args . Fullfilled "_BlockGrad(symbol)" args =>
-             String -> ArgsHMap "_BlockGrad(symbol)" args -> IO SymbolHandle
-_BlockGrad name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BlockGrad"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "make_loss(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-make_loss ::
-          forall args . Fullfilled "make_loss(symbol)" args =>
-            String -> ArgsHMap "make_loss(symbol)" args -> IO SymbolHandle
-make_loss name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "make_loss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_identity_with_attr_like_rhs(symbol)"
-     =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_identity_with_attr_like_rhs ::
-                             forall args .
-                               Fullfilled "_identity_with_attr_like_rhs(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_identity_with_attr_like_rhs(symbol)" args ->
-                                   IO SymbolHandle
-_identity_with_attr_like_rhs name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "reshape_like(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-reshape_like ::
-             forall args . Fullfilled "reshape_like(symbol)" args =>
-               String -> ArgsHMap "reshape_like(symbol)" args -> IO SymbolHandle
-reshape_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reshape_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Cast(symbol)" =
-     '[ '("dtype",
-          AttrReq
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_Cast ::
-      forall args . Fullfilled "_Cast(symbol)" args =>
-        String -> ArgsHMap "_Cast(symbol)" args -> IO SymbolHandle
-_Cast name args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Cast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cast(symbol)" = '[]
-
-_backward_cast ::
-               forall args . Fullfilled "_backward_cast(symbol)" args =>
-                 String -> ArgsHMap "_backward_cast(symbol)" args -> IO SymbolHandle
-_backward_cast name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "negative(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-negative ::
-         forall args . Fullfilled "negative(symbol)" args =>
-           String -> ArgsHMap "negative(symbol)" args -> IO SymbolHandle
-negative name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "negative"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "reciprocal(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-reciprocal ::
-           forall args . Fullfilled "reciprocal(symbol)" args =>
-             String -> ArgsHMap "reciprocal(symbol)" args -> IO SymbolHandle
-reciprocal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reciprocal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_reciprocal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_reciprocal ::
-                     forall args . Fullfilled "_backward_reciprocal(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_reciprocal(symbol)" args -> IO SymbolHandle
-_backward_reciprocal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reciprocal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "abs(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-abs ::
-    forall args . Fullfilled "abs(symbol)" args =>
-      String -> ArgsHMap "abs(symbol)" args -> IO SymbolHandle
-abs name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "abs"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_abs(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_abs ::
-              forall args . Fullfilled "_backward_abs(symbol)" args =>
-                String -> ArgsHMap "_backward_abs(symbol)" args -> IO SymbolHandle
-_backward_abs name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_abs"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sign(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sign ::
-     forall args . Fullfilled "sign(symbol)" args =>
-       String -> ArgsHMap "sign(symbol)" args -> IO SymbolHandle
-sign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sign(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sign ::
-               forall args . Fullfilled "_backward_sign(symbol)" args =>
-                 String -> ArgsHMap "_backward_sign(symbol)" args -> IO SymbolHandle
-_backward_sign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "round(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-round ::
-      forall args . Fullfilled "round(symbol)" args =>
-        String -> ArgsHMap "round(symbol)" args -> IO SymbolHandle
-round name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "round"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rint(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-rint ::
-     forall args . Fullfilled "rint(symbol)" args =>
-       String -> ArgsHMap "rint(symbol)" args -> IO SymbolHandle
-rint name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rint"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ceil(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-ceil ::
-     forall args . Fullfilled "ceil(symbol)" args =>
-       String -> ArgsHMap "ceil(symbol)" args -> IO SymbolHandle
-ceil name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ceil"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "floor(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-floor ::
-      forall args . Fullfilled "floor(symbol)" args =>
-        String -> ArgsHMap "floor(symbol)" args -> IO SymbolHandle
-floor name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "floor"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "trunc(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-trunc ::
-      forall args . Fullfilled "trunc(symbol)" args =>
-        String -> ArgsHMap "trunc(symbol)" args -> IO SymbolHandle
-trunc name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "trunc"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "fix(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-fix ::
-    forall args . Fullfilled "fix(symbol)" args =>
-      String -> ArgsHMap "fix(symbol)" args -> IO SymbolHandle
-fix name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fix"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "square(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-square ::
-       forall args . Fullfilled "square(symbol)" args =>
-         String -> ArgsHMap "square(symbol)" args -> IO SymbolHandle
-square name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "square"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_square(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_square ::
-                 forall args . Fullfilled "_backward_square(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_square(symbol)" args -> IO SymbolHandle
-_backward_square name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sqrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sqrt ::
-     forall args . Fullfilled "sqrt(symbol)" args =>
-       String -> ArgsHMap "sqrt(symbol)" args -> IO SymbolHandle
-sqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sqrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sqrt ::
-               forall args . Fullfilled "_backward_sqrt(symbol)" args =>
-                 String -> ArgsHMap "_backward_sqrt(symbol)" args -> IO SymbolHandle
-_backward_sqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rsqrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-rsqrt ::
-      forall args . Fullfilled "rsqrt(symbol)" args =>
-        String -> ArgsHMap "rsqrt(symbol)" args -> IO SymbolHandle
-rsqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rsqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rsqrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rsqrt ::
-                forall args . Fullfilled "_backward_rsqrt(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_rsqrt(symbol)" args -> IO SymbolHandle
-_backward_rsqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rsqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cbrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-cbrt ::
-     forall args . Fullfilled "cbrt(symbol)" args =>
-       String -> ArgsHMap "cbrt(symbol)" args -> IO SymbolHandle
-cbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cbrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_cbrt ::
-               forall args . Fullfilled "_backward_cbrt(symbol)" args =>
-                 String -> ArgsHMap "_backward_cbrt(symbol)" args -> IO SymbolHandle
-_backward_cbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rcbrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-rcbrt ::
-      forall args . Fullfilled "rcbrt(symbol)" args =>
-        String -> ArgsHMap "rcbrt(symbol)" args -> IO SymbolHandle
-rcbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rcbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rcbrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rcbrt ::
-                forall args . Fullfilled "_backward_rcbrt(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_rcbrt(symbol)" args -> IO SymbolHandle
-_backward_rcbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rcbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "exp(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-exp ::
-    forall args . Fullfilled "exp(symbol)" args =>
-      String -> ArgsHMap "exp(symbol)" args -> IO SymbolHandle
-exp name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "exp"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log ::
-    forall args . Fullfilled "log(symbol)" args =>
-      String -> ArgsHMap "log(symbol)" args -> IO SymbolHandle
-log name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log10(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log10 ::
-      forall args . Fullfilled "log10(symbol)" args =>
-        String -> ArgsHMap "log10(symbol)" args -> IO SymbolHandle
-log10 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log10"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log2(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log2 ::
-     forall args . Fullfilled "log2(symbol)" args =>
-       String -> ArgsHMap "log2(symbol)" args -> IO SymbolHandle
-log2 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log ::
-              forall args . Fullfilled "_backward_log(symbol)" args =>
-                String -> ArgsHMap "_backward_log(symbol)" args -> IO SymbolHandle
-_backward_log name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log10(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log10 ::
-                forall args . Fullfilled "_backward_log10(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_log10(symbol)" args -> IO SymbolHandle
-_backward_log10 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log10"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log2(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log2 ::
-               forall args . Fullfilled "_backward_log2(symbol)" args =>
-                 String -> ArgsHMap "_backward_log2(symbol)" args -> IO SymbolHandle
-_backward_log2 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log1p(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log1p ::
-      forall args . Fullfilled "log1p(symbol)" args =>
-        String -> ArgsHMap "log1p(symbol)" args -> IO SymbolHandle
-log1p name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log1p"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log1p(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log1p ::
-                forall args . Fullfilled "_backward_log1p(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_log1p(symbol)" args -> IO SymbolHandle
-_backward_log1p name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log1p"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "expm1(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-expm1 ::
-      forall args . Fullfilled "expm1(symbol)" args =>
-        String -> ArgsHMap "expm1(symbol)" args -> IO SymbolHandle
-expm1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expm1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_expm1(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_expm1 ::
-                forall args . Fullfilled "_backward_expm1(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_expm1(symbol)" args -> IO SymbolHandle
-_backward_expm1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_expm1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "gamma(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-gamma ::
-      forall args . Fullfilled "gamma(symbol)" args =>
-        String -> ArgsHMap "gamma(symbol)" args -> IO SymbolHandle
-gamma name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_gamma(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_gamma ::
-                forall args . Fullfilled "_backward_gamma(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_gamma(symbol)" args -> IO SymbolHandle
-_backward_gamma name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "gammaln(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-gammaln ::
-        forall args . Fullfilled "gammaln(symbol)" args =>
-          String -> ArgsHMap "gammaln(symbol)" args -> IO SymbolHandle
-gammaln name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gammaln"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_gammaln(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_gammaln ::
-                  forall args . Fullfilled "_backward_gammaln(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_gammaln(symbol)" args -> IO SymbolHandle
-_backward_gammaln name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gammaln"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sum(symbol)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-sum ::
-    forall args . Fullfilled "sum(symbol)" args =>
-      String -> ArgsHMap "sum(symbol)" args -> IO SymbolHandle
-sum name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sum(symbol)" = '[]
-
-_backward_sum ::
-              forall args . Fullfilled "_backward_sum(symbol)" args =>
-                String -> ArgsHMap "_backward_sum(symbol)" args -> IO SymbolHandle
-_backward_sum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "mean(symbol)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-mean ::
-     forall args . Fullfilled "mean(symbol)" args =>
-       String -> ArgsHMap "mean(symbol)" args -> IO SymbolHandle
-mean name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mean"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mean(symbol)" = '[]
-
-_backward_mean ::
-               forall args . Fullfilled "_backward_mean(symbol)" args =>
-                 String -> ArgsHMap "_backward_mean(symbol)" args -> IO SymbolHandle
-_backward_mean name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mean"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "prod(symbol)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-prod ::
-     forall args . Fullfilled "prod(symbol)" args =>
-       String -> ArgsHMap "prod(symbol)" args -> IO SymbolHandle
-prod name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "prod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_prod(symbol)" = '[]
-
-_backward_prod ::
-               forall args . Fullfilled "_backward_prod(symbol)" args =>
-                 String -> ArgsHMap "_backward_prod(symbol)" args -> IO SymbolHandle
-_backward_prod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_prod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "nansum(symbol)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-nansum ::
-       forall args . Fullfilled "nansum(symbol)" args =>
-         String -> ArgsHMap "nansum(symbol)" args -> IO SymbolHandle
-nansum name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nansum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_nansum(symbol)" = '[]
-
-_backward_nansum ::
-                 forall args . Fullfilled "_backward_nansum(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_nansum(symbol)" args -> IO SymbolHandle
-_backward_nansum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nansum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "nanprod(symbol)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-nanprod ::
-        forall args . Fullfilled "nanprod(symbol)" args =>
-          String -> ArgsHMap "nanprod(symbol)" args -> IO SymbolHandle
-nanprod name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nanprod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_nanprod(symbol)" = '[]
-
-_backward_nanprod ::
-                  forall args . Fullfilled "_backward_nanprod(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_nanprod(symbol)" args -> IO SymbolHandle
-_backward_nanprod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nanprod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "max(symbol)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-max ::
-    forall args . Fullfilled "max(symbol)" args =>
-      String -> ArgsHMap "max(symbol)" args -> IO SymbolHandle
-max name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "max"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_max(symbol)" = '[]
-
-_backward_max ::
-              forall args . Fullfilled "_backward_max(symbol)" args =>
-                String -> ArgsHMap "_backward_max(symbol)" args -> IO SymbolHandle
-_backward_max name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_max"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "min(symbol)" =
-     '[ '("axis", AttrOpt [Int]), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-min ::
-    forall args . Fullfilled "min(symbol)" args =>
-      String -> ArgsHMap "min(symbol)" args -> IO SymbolHandle
-min name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "min"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_min(symbol)" = '[]
-
-_backward_min ::
-              forall args . Fullfilled "_backward_min(symbol)" args =>
-                String -> ArgsHMap "_backward_min(symbol)" args -> IO SymbolHandle
-_backward_min name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_min"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_axis(symbol)" =
-     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-broadcast_axis ::
-               forall args . Fullfilled "broadcast_axis(symbol)" args =>
-                 String -> ArgsHMap "broadcast_axis(symbol)" args -> IO SymbolHandle
-broadcast_axis name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_axis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_to(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-broadcast_to ::
-             forall args . Fullfilled "broadcast_to(symbol)" args =>
-               String -> ArgsHMap "broadcast_to(symbol)" args -> IO SymbolHandle
-broadcast_to name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_to"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_broadcast_backward(symbol)" = '[]
-
-_broadcast_backward ::
-                    forall args . Fullfilled "_broadcast_backward(symbol)" args =>
-                      String ->
-                        ArgsHMap "_broadcast_backward(symbol)" args -> IO SymbolHandle
-_broadcast_backward name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_broadcast_backward"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "norm(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-norm ::
-     forall args . Fullfilled "norm(symbol)" args =>
-       String -> ArgsHMap "norm(symbol)" args -> IO SymbolHandle
-norm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "norm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_add(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_add ::
-             forall args . Fullfilled "elemwise_add(symbol)" args =>
-               String -> ArgsHMap "elemwise_add(symbol)" args -> IO SymbolHandle
-elemwise_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_grad_add(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_grad_add ::
-          forall args . Fullfilled "_grad_add(symbol)" args =>
-            String -> ArgsHMap "_grad_add(symbol)" args -> IO SymbolHandle
-_grad_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_grad_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_add(symbol)" = '[]
-
-_backward_add ::
-              forall args . Fullfilled "_backward_add(symbol)" args =>
-                String -> ArgsHMap "_backward_add(symbol)" args -> IO SymbolHandle
-_backward_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_sub(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_sub ::
-             forall args . Fullfilled "elemwise_sub(symbol)" args =>
-               String -> ArgsHMap "elemwise_sub(symbol)" args -> IO SymbolHandle
-elemwise_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sub(symbol)" = '[]
-
-_backward_sub ::
-              forall args . Fullfilled "_backward_sub(symbol)" args =>
-                String -> ArgsHMap "_backward_sub(symbol)" args -> IO SymbolHandle
-_backward_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_mul(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_mul ::
-             forall args . Fullfilled "elemwise_mul(symbol)" args =>
-               String -> ArgsHMap "elemwise_mul(symbol)" args -> IO SymbolHandle
-elemwise_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mul(symbol)" = '[]
-
-_backward_mul ::
-              forall args . Fullfilled "_backward_mul(symbol)" args =>
-                String -> ArgsHMap "_backward_mul(symbol)" args -> IO SymbolHandle
-_backward_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_div(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_div ::
-             forall args . Fullfilled "elemwise_div(symbol)" args =>
-               String -> ArgsHMap "elemwise_div(symbol)" args -> IO SymbolHandle
-elemwise_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_div(symbol)" = '[]
-
-_backward_div ::
-              forall args . Fullfilled "_backward_div(symbol)" args =>
-                String -> ArgsHMap "_backward_div(symbol)" args -> IO SymbolHandle
-_backward_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_mod(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_mod ::
-     forall args . Fullfilled "_mod(symbol)" args =>
-       String -> ArgsHMap "_mod(symbol)" args -> IO SymbolHandle
-_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mod(symbol)" = '[]
-
-_backward_mod ::
-              forall args . Fullfilled "_backward_mod(symbol)" args =>
-                String -> ArgsHMap "_backward_mod(symbol)" args -> IO SymbolHandle
-_backward_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_plus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_plus_scalar ::
-             forall args . Fullfilled "_plus_scalar(symbol)" args =>
-               String -> ArgsHMap "_plus_scalar(symbol)" args -> IO SymbolHandle
-_plus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_plus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_minus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_minus_scalar ::
-              forall args . Fullfilled "_minus_scalar(symbol)" args =>
-                String -> ArgsHMap "_minus_scalar(symbol)" args -> IO SymbolHandle
-_minus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rminus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rminus_scalar ::
-               forall args . Fullfilled "_rminus_scalar(symbol)" args =>
-                 String -> ArgsHMap "_rminus_scalar(symbol)" args -> IO SymbolHandle
-_rminus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rminus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_mul_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_mul_scalar ::
-            forall args . Fullfilled "_mul_scalar(symbol)" args =>
-              String -> ArgsHMap "_mul_scalar(symbol)" args -> IO SymbolHandle
-_mul_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mul_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mul_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_backward_mul_scalar ::
-                     forall args . Fullfilled "_backward_mul_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_mul_scalar(symbol)" args -> IO SymbolHandle
-_backward_mul_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_div_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_div_scalar ::
-            forall args . Fullfilled "_div_scalar(symbol)" args =>
-              String -> ArgsHMap "_div_scalar(symbol)" args -> IO SymbolHandle
-_div_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_div_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_div_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_backward_div_scalar ::
-                     forall args . Fullfilled "_backward_div_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_div_scalar(symbol)" args -> IO SymbolHandle
-_backward_div_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rdiv_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rdiv_scalar ::
-             forall args . Fullfilled "_rdiv_scalar(symbol)" args =>
-               String -> ArgsHMap "_rdiv_scalar(symbol)" args -> IO SymbolHandle
-_rdiv_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rdiv_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rdiv_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rdiv_scalar ::
-                      forall args . Fullfilled "_backward_rdiv_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_rdiv_scalar(symbol)" args -> IO SymbolHandle
-_backward_rdiv_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rdiv_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_mod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_mod_scalar ::
-            forall args . Fullfilled "_mod_scalar(symbol)" args =>
-              String -> ArgsHMap "_mod_scalar(symbol)" args -> IO SymbolHandle
-_mod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_mod_scalar ::
-                     forall args . Fullfilled "_backward_mod_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_mod_scalar(symbol)" args -> IO SymbolHandle
-_backward_mod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rmod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rmod_scalar ::
-             forall args . Fullfilled "_rmod_scalar(symbol)" args =>
-               String -> ArgsHMap "_rmod_scalar(symbol)" args -> IO SymbolHandle
-_rmod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rmod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rmod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rmod_scalar ::
-                      forall args . Fullfilled "_backward_rmod_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_rmod_scalar(symbol)" args -> IO SymbolHandle
-_backward_rmod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rmod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_elemwise_div(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_scatter_elemwise_div ::
-                      forall args . Fullfilled "_scatter_elemwise_div(symbol)" args =>
-                        String ->
-                          ArgsHMap "_scatter_elemwise_div(symbol)" args -> IO SymbolHandle
-_scatter_elemwise_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_elemwise_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_plus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_scatter_plus_scalar ::
-                     forall args . Fullfilled "_scatter_plus_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_scatter_plus_scalar(symbol)" args -> IO SymbolHandle
-_scatter_plus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_plus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_minus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_scatter_minus_scalar ::
-                      forall args . Fullfilled "_scatter_minus_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_scatter_minus_scalar(symbol)" args -> IO SymbolHandle
-_scatter_minus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_minus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Embedding(symbol)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle)]
-
-_Embedding ::
-           forall args . Fullfilled "_Embedding(symbol)" args =>
-             String -> ArgsHMap "_Embedding(symbol)" args -> IO SymbolHandle
-_Embedding name args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Embedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_SparseEmbedding(symbol)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle)]
-
-_contrib_SparseEmbedding ::
-                         forall args . Fullfilled "_contrib_SparseEmbedding(symbol)" args =>
-                           String ->
-                             ArgsHMap "_contrib_SparseEmbedding(symbol)" args -> IO SymbolHandle
-_contrib_SparseEmbedding name args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SparseEmbedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Embedding(symbol)" = '[]
-
-_backward_Embedding ::
-                    forall args . Fullfilled "_backward_Embedding(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_Embedding(symbol)" args -> IO SymbolHandle
-_backward_Embedding name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Embedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SparseEmbedding(symbol)" =
-     '[]
-
-_backward_SparseEmbedding ::
-                          forall args .
-                            Fullfilled "_backward_SparseEmbedding(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_SparseEmbedding(symbol)" args ->
-                                IO SymbolHandle
-_backward_SparseEmbedding name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SparseEmbedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "take(symbol)" =
-     '[ '("axis", AttrOpt Int),
-        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),
-        '("a", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)]
-
-take ::
-     forall args . Fullfilled "take(symbol)" args =>
-       String -> ArgsHMap "take(symbol)" args -> IO SymbolHandle
-take name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "take"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_take(symbol)" = '[]
-
-_backward_take ::
-               forall args . Fullfilled "_backward_take(symbol)" args =>
-                 String -> ArgsHMap "_backward_take(symbol)" args -> IO SymbolHandle
-_backward_take name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_take"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "batch_take(symbol)" =
-     '[ '("a", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-batch_take ::
-           forall args . Fullfilled "batch_take(symbol)" args =>
-             String -> ArgsHMap "batch_take(symbol)" args -> IO SymbolHandle
-batch_take name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_take"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "one_hot(symbol)" =
-     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),
-        '("off_value", AttrOpt Double),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("indices", AttrOpt SymbolHandle)]
-
-one_hot ::
-        forall args . Fullfilled "one_hot(symbol)" args =>
-          String -> ArgsHMap "one_hot(symbol)" args -> IO SymbolHandle
-one_hot name args
-  = let scalarArgs
-          = catMaybes
-              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),
-               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),
-               ("off_value",) . showValue <$>
-                 (args !? #off_value :: Maybe Double),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "one_hot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "gather_nd(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-gather_nd ::
-          forall args . Fullfilled "gather_nd(symbol)" args =>
-            String -> ArgsHMap "gather_nd(symbol)" args -> IO SymbolHandle
-gather_nd name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gather_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "scatter_nd(symbol)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-scatter_nd ::
-           forall args . Fullfilled "scatter_nd(symbol)" args =>
-             String -> ArgsHMap "scatter_nd(symbol)" args -> IO SymbolHandle
-scatter_nd name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "scatter_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_set_nd(symbol)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-_scatter_set_nd ::
-                forall args . Fullfilled "_scatter_set_nd(symbol)" args =>
-                  String ->
-                    ArgsHMap "_scatter_set_nd(symbol)" args -> IO SymbolHandle
-_scatter_set_nd name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_set_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_equal ::
-                forall args . Fullfilled "broadcast_equal(symbol)" args =>
-                  String ->
-                    ArgsHMap "broadcast_equal(symbol)" args -> IO SymbolHandle
-broadcast_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_not_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_not_equal ::
-                    forall args . Fullfilled "broadcast_not_equal(symbol)" args =>
-                      String ->
-                        ArgsHMap "broadcast_not_equal(symbol)" args -> IO SymbolHandle
-broadcast_not_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_not_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_greater(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_greater ::
-                  forall args . Fullfilled "broadcast_greater(symbol)" args =>
-                    String ->
-                      ArgsHMap "broadcast_greater(symbol)" args -> IO SymbolHandle
-broadcast_greater name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_greater_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_greater_equal ::
-                        forall args . Fullfilled "broadcast_greater_equal(symbol)" args =>
-                          String ->
-                            ArgsHMap "broadcast_greater_equal(symbol)" args -> IO SymbolHandle
-broadcast_greater_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_lesser(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_lesser ::
-                 forall args . Fullfilled "broadcast_lesser(symbol)" args =>
-                   String ->
-                     ArgsHMap "broadcast_lesser(symbol)" args -> IO SymbolHandle
-broadcast_lesser name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_lesser_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_lesser_equal ::
-                       forall args . Fullfilled "broadcast_lesser_equal(symbol)" args =>
-                         String ->
-                           ArgsHMap "broadcast_lesser_equal(symbol)" args -> IO SymbolHandle
-broadcast_lesser_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argmax(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-argmax ::
-       forall args . Fullfilled "argmax(symbol)" args =>
-         String -> ArgsHMap "argmax(symbol)" args -> IO SymbolHandle
-argmax name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argmin(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-argmin ::
-       forall args . Fullfilled "argmin(symbol)" args =>
-         String -> ArgsHMap "argmin(symbol)" args -> IO SymbolHandle
-argmin name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argmax_channel(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-argmax_channel ::
-               forall args . Fullfilled "argmax_channel(symbol)" args =>
-                 String -> ArgsHMap "argmax_channel(symbol)" args -> IO SymbolHandle
-argmax_channel name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax_channel"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "pick(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle), '("index", AttrOpt SymbolHandle)]
-
-pick ::
-     forall args . Fullfilled "pick(symbol)" args =>
-       String -> ArgsHMap "pick(symbol)" args -> IO SymbolHandle
-pick name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("index",) <$> (args !? #index :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "pick"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_pick(symbol)" = '[]
-
-_backward_pick ::
-               forall args . Fullfilled "_backward_pick(symbol)" args =>
-                 String -> ArgsHMap "_backward_pick(symbol)" args -> IO SymbolHandle
-_backward_pick name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_pick"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sparse_retain(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-_sparse_retain ::
-               forall args . Fullfilled "_sparse_retain(symbol)" args =>
-                 String -> ArgsHMap "_sparse_retain(symbol)" args -> IO SymbolHandle
-_sparse_retain name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_retain"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sparse_retain(symbol)" = '[]
-
-_backward_sparse_retain ::
-                        forall args . Fullfilled "_backward_sparse_retain(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_sparse_retain(symbol)" args -> IO SymbolHandle
-_backward_sparse_retain name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sparse_retain"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_where(symbol)" =
-     '[ '("condition", AttrOpt SymbolHandle),
-        '("x", AttrOpt SymbolHandle), '("y", AttrOpt SymbolHandle)]
-
-_where ::
-       forall args . Fullfilled "_where(symbol)" args =>
-         String -> ArgsHMap "_where(symbol)" args -> IO SymbolHandle
-_where name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("condition",) <$> (args !? #condition :: Maybe SymbolHandle),
-               ("x",) <$> (args !? #x :: Maybe SymbolHandle),
-               ("y",) <$> (args !? #y :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "where"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_where(symbol)" = '[]
-
-_backward_where ::
-                forall args . Fullfilled "_backward_where(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_where(symbol)" args -> IO SymbolHandle
-_backward_where name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_where"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_maximum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_maximum_scalar ::
-                forall args . Fullfilled "_maximum_scalar(symbol)" args =>
-                  String ->
-                    ArgsHMap "_maximum_scalar(symbol)" args -> IO SymbolHandle
-_maximum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_maximum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_maximum_scalar ::
-                         forall args . Fullfilled "_backward_maximum_scalar(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_maximum_scalar(symbol)" args -> IO SymbolHandle
-_backward_maximum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_minimum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_minimum_scalar ::
-                forall args . Fullfilled "_minimum_scalar(symbol)" args =>
-                  String ->
-                    ArgsHMap "_minimum_scalar(symbol)" args -> IO SymbolHandle
-_minimum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_minimum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_minimum_scalar ::
-                         forall args . Fullfilled "_backward_minimum_scalar(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_minimum_scalar(symbol)" args -> IO SymbolHandle
-_backward_minimum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_power_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_power_scalar ::
-              forall args . Fullfilled "_power_scalar(symbol)" args =>
-                String -> ArgsHMap "_power_scalar(symbol)" args -> IO SymbolHandle
-_power_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_power_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_power_scalar ::
-                       forall args . Fullfilled "_backward_power_scalar(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_power_scalar(symbol)" args -> IO SymbolHandle
-_backward_power_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rpower_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rpower_scalar ::
-               forall args . Fullfilled "_rpower_scalar(symbol)" args =>
-                 String -> ArgsHMap "_rpower_scalar(symbol)" args -> IO SymbolHandle
-_rpower_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rpower_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rpower_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rpower_scalar ::
-                        forall args . Fullfilled "_backward_rpower_scalar(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_rpower_scalar(symbol)" args -> IO SymbolHandle
-_backward_rpower_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rpower_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_hypot_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_hypot_scalar ::
-              forall args . Fullfilled "_hypot_scalar(symbol)" args =>
-                String -> ArgsHMap "_hypot_scalar(symbol)" args -> IO SymbolHandle
-_hypot_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_hypot_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_hypot_scalar ::
-                       forall args . Fullfilled "_backward_hypot_scalar(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_hypot_scalar(symbol)" args -> IO SymbolHandle
-_backward_hypot_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "smooth_l1(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-smooth_l1 ::
-          forall args . Fullfilled "smooth_l1(symbol)" args =>
-            String -> ArgsHMap "smooth_l1(symbol)" args -> IO SymbolHandle
-smooth_l1 name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "smooth_l1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_smooth_l1(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_smooth_l1 ::
-                    forall args . Fullfilled "_backward_smooth_l1(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_smooth_l1(symbol)" args -> IO SymbolHandle
-_backward_smooth_l1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_smooth_l1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "topk(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),
-        '("ret_typ",
-          AttrOpt (EnumType '["both", "indices", "mask", "value"])),
-        '("is_ascend", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-topk ::
-     forall args . Fullfilled "topk(symbol)" args =>
-       String -> ArgsHMap "topk(symbol)" args -> IO SymbolHandle
-topk name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ret_typ",) . showValue <$>
-                 (args !? #ret_typ ::
-                    Maybe (EnumType '["both", "indices", "mask", "value"])),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "topk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_topk(symbol)" = '[]
-
-_backward_topk ::
-               forall args . Fullfilled "_backward_topk(symbol)" args =>
-                 String -> ArgsHMap "_backward_topk(symbol)" args -> IO SymbolHandle
-_backward_topk name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_topk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sort(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-sort ::
-     forall args . Fullfilled "sort(symbol)" args =>
-       String -> ArgsHMap "sort(symbol)" args -> IO SymbolHandle
-sort name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sort"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argsort(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-argsort ::
-        forall args . Fullfilled "argsort(symbol)" args =>
-          String -> ArgsHMap "argsort(symbol)" args -> IO SymbolHandle
-argsort name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argsort"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Reshape(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),
-        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-_Reshape ::
-         forall args . Fullfilled "_Reshape(symbol)" args =>
-           String -> ArgsHMap "_Reshape(symbol)" args -> IO SymbolHandle
-_Reshape name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("keep_highest",) . showValue <$>
-                 (args !? #keep_highest :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Reshape"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Flatten(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_Flatten ::
-         forall args . Fullfilled "_Flatten(symbol)" args =>
-           String -> ArgsHMap "_Flatten(symbol)" args -> IO SymbolHandle
-_Flatten name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Flatten"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "transpose(symbol)" =
-     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-transpose ::
-          forall args . Fullfilled "transpose(symbol)" args =>
-            String -> ArgsHMap "transpose(symbol)" args -> IO SymbolHandle
-transpose name args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "transpose"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "expand_dims(symbol)" =
-     '[ '("axis", AttrReq Int), '("data", AttrOpt SymbolHandle)]
-
-expand_dims ::
-            forall args . Fullfilled "expand_dims(symbol)" args =>
-              String -> ArgsHMap "expand_dims(symbol)" args -> IO SymbolHandle
-expand_dims name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expand_dims"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "slice(symbol)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-slice ::
-      forall args . Fullfilled "slice(symbol)" args =>
-        String -> ArgsHMap "slice(symbol)" args -> IO SymbolHandle
-slice name args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_slice(symbol)" = '[]
-
-_backward_slice ::
-                forall args . Fullfilled "_backward_slice(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_slice(symbol)" args -> IO SymbolHandle
-_backward_slice name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_slice_assign(symbol)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_slice_assign ::
-              forall args . Fullfilled "_slice_assign(symbol)" args =>
-                String -> ArgsHMap "_slice_assign(symbol)" args -> IO SymbolHandle
-_slice_assign name args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_slice_assign_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("begin", AttrReq [Int]),
-        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-_slice_assign_scalar ::
-                     forall args . Fullfilled "_slice_assign_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_slice_assign_scalar(symbol)" args -> IO SymbolHandle
-_slice_assign_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "slice_axis(symbol)" =
-     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),
-        '("end", AttrReq (Maybe Int)), '("data", AttrOpt SymbolHandle)]
-
-slice_axis ::
-           forall args . Fullfilled "slice_axis(symbol)" args =>
-             String -> ArgsHMap "slice_axis(symbol)" args -> IO SymbolHandle
-slice_axis name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),
-               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_axis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_slice_axis(symbol)" = '[]
-
-_backward_slice_axis ::
-                     forall args . Fullfilled "_backward_slice_axis(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_slice_axis(symbol)" args -> IO SymbolHandle
-_backward_slice_axis name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_axis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "clip(symbol)" =
-     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-clip ::
-     forall args . Fullfilled "clip(symbol)" args =>
-       String -> ArgsHMap "clip(symbol)" args -> IO SymbolHandle
-clip name args
-  = let scalarArgs
-          = catMaybes
-              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),
-               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "clip"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_clip(symbol)" = '[]
-
-_backward_clip ::
-               forall args . Fullfilled "_backward_clip(symbol)" args =>
-                 String -> ArgsHMap "_backward_clip(symbol)" args -> IO SymbolHandle
-_backward_clip name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_clip"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "repeat(symbol)" =
-     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),
-        '("data", AttrOpt SymbolHandle)]
-
-repeat ::
-       forall args . Fullfilled "repeat(symbol)" args =>
-         String -> ArgsHMap "repeat(symbol)" args -> IO SymbolHandle
-repeat name args
-  = let scalarArgs
-          = catMaybes
-              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "repeat"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_repeat(symbol)" = '[]
-
-_backward_repeat ::
-                 forall args . Fullfilled "_backward_repeat(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_repeat(symbol)" args -> IO SymbolHandle
-_backward_repeat name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_repeat"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "tile(symbol)" =
-     '[ '("reps", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]
-
-tile ::
-     forall args . Fullfilled "tile(symbol)" args =>
-       String -> ArgsHMap "tile(symbol)" args -> IO SymbolHandle
-tile name args
-  = let scalarArgs
-          = catMaybes
-              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tile"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_tile(symbol)" = '[]
-
-_backward_tile ::
-               forall args . Fullfilled "_backward_tile(symbol)" args =>
-                 String -> ArgsHMap "_backward_tile(symbol)" args -> IO SymbolHandle
-_backward_tile name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tile"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "reverse(symbol)" =
-     '[ '("axis", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]
-
-reverse ::
-        forall args . Fullfilled "reverse(symbol)" args =>
-          String -> ArgsHMap "reverse(symbol)" args -> IO SymbolHandle
-reverse name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_reverse(symbol)" = '[]
-
-_backward_reverse ::
-                  forall args . Fullfilled "_backward_reverse(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_reverse(symbol)" args -> IO SymbolHandle
-_backward_reverse name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "stack(symbol)" =
-     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-stack ::
-      forall args . Fullfilled "stack(symbol)" args =>
-        String -> ArgsHMap "stack(symbol)" args -> IO SymbolHandle
-stack name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "stack"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_stack(symbol)" = '[]
-
-_backward_stack ::
-                forall args . Fullfilled "_backward_stack(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_stack(symbol)" args -> IO SymbolHandle
-_backward_stack name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_stack"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "dot(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-dot ::
-    forall args . Fullfilled "dot(symbol)" args =>
-      String -> ArgsHMap "dot(symbol)" args -> IO SymbolHandle
-dot name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_dot(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool)]
-
-_backward_dot ::
-              forall args . Fullfilled "_backward_dot(symbol)" args =>
-                String -> ArgsHMap "_backward_dot(symbol)" args -> IO SymbolHandle
-_backward_dot name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "batch_dot(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-batch_dot ::
-          forall args . Fullfilled "batch_dot(symbol)" args =>
-            String -> ArgsHMap "batch_dot(symbol)" args -> IO SymbolHandle
-batch_dot name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_batch_dot(symbol)" = '[]
-
-_backward_batch_dot ::
-                    forall args . Fullfilled "_backward_batch_dot(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_batch_dot(symbol)" args -> IO SymbolHandle
-_backward_batch_dot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_batch_dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sin(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sin ::
-    forall args . Fullfilled "sin(symbol)" args =>
-      String -> ArgsHMap "sin(symbol)" args -> IO SymbolHandle
-sin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sin(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sin ::
-              forall args . Fullfilled "_backward_sin(symbol)" args =>
-                String -> ArgsHMap "_backward_sin(symbol)" args -> IO SymbolHandle
-_backward_sin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cos(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-cos ::
-    forall args . Fullfilled "cos(symbol)" args =>
-      String -> ArgsHMap "cos(symbol)" args -> IO SymbolHandle
-cos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cos(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_cos ::
-              forall args . Fullfilled "_backward_cos(symbol)" args =>
-                String -> ArgsHMap "_backward_cos(symbol)" args -> IO SymbolHandle
-_backward_cos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "tan(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-tan ::
-    forall args . Fullfilled "tan(symbol)" args =>
-      String -> ArgsHMap "tan(symbol)" args -> IO SymbolHandle
-tan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_tan(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_tan ::
-              forall args . Fullfilled "_backward_tan(symbol)" args =>
-                String -> ArgsHMap "_backward_tan(symbol)" args -> IO SymbolHandle
-_backward_tan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arcsin(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arcsin ::
-       forall args . Fullfilled "arcsin(symbol)" args =>
-         String -> ArgsHMap "arcsin(symbol)" args -> IO SymbolHandle
-arcsin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arcsin(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arcsin ::
-                 forall args . Fullfilled "_backward_arcsin(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_arcsin(symbol)" args -> IO SymbolHandle
-_backward_arcsin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arccos(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arccos ::
-       forall args . Fullfilled "arccos(symbol)" args =>
-         String -> ArgsHMap "arccos(symbol)" args -> IO SymbolHandle
-arccos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arccos(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arccos ::
-                 forall args . Fullfilled "_backward_arccos(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_arccos(symbol)" args -> IO SymbolHandle
-_backward_arccos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arctan(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arctan ::
-       forall args . Fullfilled "arctan(symbol)" args =>
-         String -> ArgsHMap "arctan(symbol)" args -> IO SymbolHandle
-arctan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arctan(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arctan ::
-                 forall args . Fullfilled "_backward_arctan(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_arctan(symbol)" args -> IO SymbolHandle
-_backward_arctan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "degrees(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-degrees ::
-        forall args . Fullfilled "degrees(symbol)" args =>
-          String -> ArgsHMap "degrees(symbol)" args -> IO SymbolHandle
-degrees name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "degrees"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_degrees(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_degrees ::
-                  forall args . Fullfilled "_backward_degrees(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_degrees(symbol)" args -> IO SymbolHandle
-_backward_degrees name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_degrees"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "radians(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-radians ::
-        forall args . Fullfilled "radians(symbol)" args =>
-          String -> ArgsHMap "radians(symbol)" args -> IO SymbolHandle
-radians name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "radians"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_radians(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_radians ::
-                  forall args . Fullfilled "_backward_radians(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_radians(symbol)" args -> IO SymbolHandle
-_backward_radians name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_radians"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sinh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sinh ::
-     forall args . Fullfilled "sinh(symbol)" args =>
-       String -> ArgsHMap "sinh(symbol)" args -> IO SymbolHandle
-sinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sinh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sinh ::
-               forall args . Fullfilled "_backward_sinh(symbol)" args =>
-                 String -> ArgsHMap "_backward_sinh(symbol)" args -> IO SymbolHandle
-_backward_sinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cosh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-cosh ::
-     forall args . Fullfilled "cosh(symbol)" args =>
-       String -> ArgsHMap "cosh(symbol)" args -> IO SymbolHandle
-cosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cosh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_cosh ::
-               forall args . Fullfilled "_backward_cosh(symbol)" args =>
-                 String -> ArgsHMap "_backward_cosh(symbol)" args -> IO SymbolHandle
-_backward_cosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "tanh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-tanh ::
-     forall args . Fullfilled "tanh(symbol)" args =>
-       String -> ArgsHMap "tanh(symbol)" args -> IO SymbolHandle
-tanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_tanh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_tanh ::
-               forall args . Fullfilled "_backward_tanh(symbol)" args =>
-                 String -> ArgsHMap "_backward_tanh(symbol)" args -> IO SymbolHandle
-_backward_tanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arcsinh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arcsinh ::
-        forall args . Fullfilled "arcsinh(symbol)" args =>
-          String -> ArgsHMap "arcsinh(symbol)" args -> IO SymbolHandle
-arcsinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arcsinh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arcsinh ::
-                  forall args . Fullfilled "_backward_arcsinh(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_arcsinh(symbol)" args -> IO SymbolHandle
-_backward_arcsinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arccosh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arccosh ::
-        forall args . Fullfilled "arccosh(symbol)" args =>
-          String -> ArgsHMap "arccosh(symbol)" args -> IO SymbolHandle
-arccosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arccosh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arccosh ::
-                  forall args . Fullfilled "_backward_arccosh(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_arccosh(symbol)" args -> IO SymbolHandle
-_backward_arccosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arctanh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arctanh ::
-        forall args . Fullfilled "arctanh(symbol)" args =>
-          String -> ArgsHMap "arctanh(symbol)" args -> IO SymbolHandle
-arctanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arctanh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arctanh ::
-                  forall args . Fullfilled "_backward_arctanh(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_arctanh(symbol)" args -> IO SymbolHandle
-_backward_arctanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_dequantize(symbol)" =
-     '[ '("out_type", AttrReq (EnumType '["float32"])),
-        '("input", AttrOpt SymbolHandle),
-        '("min_range", AttrOpt SymbolHandle),
-        '("max_range", AttrOpt SymbolHandle)]
-
-_contrib_dequantize ::
-                    forall args . Fullfilled "_contrib_dequantize(symbol)" args =>
-                      String ->
-                        ArgsHMap "_contrib_dequantize(symbol)" args -> IO SymbolHandle
-_contrib_dequantize name args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["float32"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("input",) <$> (args !? #input :: Maybe SymbolHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dequantize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_CTCLoss(symbol)" =
-     '[ '("use_data_lengths", AttrOpt Bool),
-        '("use_label_lengths", AttrOpt Bool),
-        '("blank_label", AttrOpt (EnumType '["first", "last"])),
-        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle),
-        '("data_lengths", AttrOpt SymbolHandle),
-        '("label_lengths", AttrOpt SymbolHandle)]
-
-_contrib_CTCLoss ::
-                 forall args . Fullfilled "_contrib_CTCLoss(symbol)" args =>
-                   String ->
-                     ArgsHMap "_contrib_CTCLoss(symbol)" args -> IO SymbolHandle
-_contrib_CTCLoss name args
-  = let scalarArgs
-          = catMaybes
-              [("use_data_lengths",) . showValue <$>
-                 (args !? #use_data_lengths :: Maybe Bool),
-               ("use_label_lengths",) . showValue <$>
-                 (args !? #use_label_lengths :: Maybe Bool),
-               ("blank_label",) . showValue <$>
-                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle),
-               ("data_lengths",) <$>
-                 (args !? #data_lengths :: Maybe SymbolHandle),
-               ("label_lengths",) <$>
-                 (args !? #label_lengths :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_CTCLoss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantize(symbol)" =
-     '[ '("out_type", AttrOpt (EnumType '["uint8"])),
-        '("input", AttrOpt SymbolHandle),
-        '("min_range", AttrOpt SymbolHandle),
-        '("max_range", AttrOpt SymbolHandle)]
-
-_contrib_quantize ::
-                  forall args . Fullfilled "_contrib_quantize(symbol)" args =>
-                    String ->
-                      ArgsHMap "_contrib_quantize(symbol)" args -> IO SymbolHandle
-_contrib_quantize name args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("input",) <$> (args !? #input :: Maybe SymbolHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Custom(symbol)" =
-     '[ '("op_type", AttrOpt String), '("data", AttrOpt [SymbolHandle])]
-
-_Custom ::
-        forall args .
-          (Fullfilled "_Custom(symbol)" args,
-           PopKey (ArgOf "_Custom(symbol)") args "data",
-           Dump (PopResult (ArgOf "_Custom(symbol)") args "data")) =>
-          String -> ArgsHMap "_Custom(symbol)" args -> IO SymbolHandle
-_Custom name args
-  = let scalarArgs = dump (pop args #data)
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "Custom"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_Custom(symbol)" = '[]
-
-_backward_Custom ::
-                 forall args . Fullfilled "_backward_Custom(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_Custom(symbol)" args -> IO SymbolHandle
-_backward_Custom name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Custom"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_multinomial(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),
-        '("dtype", AttrOpt (EnumType '["int32"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_sample_multinomial ::
-                    forall args . Fullfilled "_sample_multinomial(symbol)" args =>
-                      String ->
-                        ArgsHMap "_sample_multinomial(symbol)" args -> IO SymbolHandle
-_sample_multinomial name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype :: Maybe (EnumType '["int32"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_multinomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sample_multinomial(symbol)"
-     = '[]
-
-_backward_sample_multinomial ::
-                             forall args .
-                               Fullfilled "_backward_sample_multinomial(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_backward_sample_multinomial(symbol)" args ->
-                                   IO SymbolHandle
-_backward_sample_multinomial name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sample_multinomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_uniform(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("low", AttrOpt SymbolHandle), '("high", AttrOpt SymbolHandle)]
-
-_sample_uniform ::
-                forall args . Fullfilled "_sample_uniform(symbol)" args =>
-                  String ->
-                    ArgsHMap "_sample_uniform(symbol)" args -> IO SymbolHandle
-_sample_uniform name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("low",) <$> (args !? #low :: Maybe SymbolHandle),
-               ("high",) <$> (args !? #high :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_uniform"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_normal(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt SymbolHandle), '("sigma", AttrOpt SymbolHandle)]
-
-_sample_normal ::
-               forall args . Fullfilled "_sample_normal(symbol)" args =>
-                 String -> ArgsHMap "_sample_normal(symbol)" args -> IO SymbolHandle
-_sample_normal name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),
-               ("sigma",) <$> (args !? #sigma :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_normal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_gamma(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]
-
-_sample_gamma ::
-              forall args . Fullfilled "_sample_gamma(symbol)" args =>
-                String -> ArgsHMap "_sample_gamma(symbol)" args -> IO SymbolHandle
-_sample_gamma name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_exponential(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt SymbolHandle)]
-
-_sample_exponential ::
-                    forall args . Fullfilled "_sample_exponential(symbol)" args =>
-                      String ->
-                        ArgsHMap "_sample_exponential(symbol)" args -> IO SymbolHandle
-_sample_exponential name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_exponential"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_poisson(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt SymbolHandle)]
-
-_sample_poisson ::
-                forall args . Fullfilled "_sample_poisson(symbol)" args =>
-                  String ->
-                    ArgsHMap "_sample_poisson(symbol)" args -> IO SymbolHandle
-_sample_poisson name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_poisson"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_negative_binomial(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("k", AttrOpt SymbolHandle), '("p", AttrOpt SymbolHandle)]
-
-_sample_negative_binomial ::
-                          forall args .
-                            Fullfilled "_sample_negative_binomial(symbol)" args =>
-                            String ->
-                              ArgsHMap "_sample_negative_binomial(symbol)" args ->
-                                IO SymbolHandle
-_sample_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("k",) <$> (args !? #k :: Maybe SymbolHandle),
-               ("p",) <$> (args !? #p :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_sample_generalized_negative_binomial(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt SymbolHandle), '("alpha", AttrOpt SymbolHandle)]
-
-_sample_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_sample_generalized_negative_binomial(symbol)"
-                                          args =>
-                                        String ->
-                                          ArgsHMap "_sample_generalized_negative_binomial(symbol)"
-                                            args
-                                            -> IO SymbolHandle
-_sample_generalized_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_uniform(symbol)" =
-     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_uniform ::
-                forall args . Fullfilled "_random_uniform(symbol)" args =>
-                  String ->
-                    ArgsHMap "_random_uniform(symbol)" args -> IO SymbolHandle
-_random_uniform name args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_normal(symbol)" =
-     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_normal ::
-               forall args . Fullfilled "_random_normal(symbol)" args =>
-                 String -> ArgsHMap "_random_normal(symbol)" args -> IO SymbolHandle
-_random_normal name args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_gamma(symbol)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_gamma ::
-              forall args . Fullfilled "_random_gamma(symbol)" args =>
-                String -> ArgsHMap "_random_gamma(symbol)" args -> IO SymbolHandle
-_random_gamma name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_exponential(symbol)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_exponential ::
-                    forall args . Fullfilled "_random_exponential(symbol)" args =>
-                      String ->
-                        ArgsHMap "_random_exponential(symbol)" args -> IO SymbolHandle
-_random_exponential name args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_poisson(symbol)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_poisson ::
-                forall args . Fullfilled "_random_poisson(symbol)" args =>
-                  String ->
-                    ArgsHMap "_random_poisson(symbol)" args -> IO SymbolHandle
-_random_poisson name args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_negative_binomial(symbol)" =
-     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_negative_binomial ::
-                          forall args .
-                            Fullfilled "_random_negative_binomial(symbol)" args =>
-                            String ->
-                              ArgsHMap "_random_negative_binomial(symbol)" args ->
-                                IO SymbolHandle
-_random_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_random_generalized_negative_binomial(symbol)" =
-     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_random_generalized_negative_binomial(symbol)"
-                                          args =>
-                                        String ->
-                                          ArgsHMap "_random_generalized_negative_binomial(symbol)"
-                                            args
-                                            -> IO SymbolHandle
-_random_generalized_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "softmax(symbol)" =
-     '[ '("axis", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-softmax ::
-        forall args . Fullfilled "softmax(symbol)" args =>
-          String -> ArgsHMap "softmax(symbol)" args -> IO SymbolHandle
-softmax name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_softmax(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_softmax ::
-                  forall args . Fullfilled "_backward_softmax(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_softmax(symbol)" args -> IO SymbolHandle
-_backward_softmax name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log_softmax(symbol)" =
-     '[ '("axis", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-log_softmax ::
-            forall args . Fullfilled "log_softmax(symbol)" args =>
-              String -> ArgsHMap "log_softmax(symbol)" args -> IO SymbolHandle
-log_softmax name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log_softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log_softmax(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log_softmax ::
-                      forall args . Fullfilled "_backward_log_softmax(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_log_softmax(symbol)" args -> IO SymbolHandle
-_backward_log_softmax name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log_softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_cvimread(symbol)" =
-     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),
-        '("to_rgb", AttrOpt Bool)]
-
-_cvimread ::
-          forall args . Fullfilled "_cvimread(symbol)" args =>
-            String -> ArgsHMap "_cvimread(symbol)" args -> IO SymbolHandle
-_cvimread name args
-  = let scalarArgs
-          = catMaybes
-              [("filename",) . showValue <$> (args !? #filename :: Maybe String),
-               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimread"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_NoGradient(symbol)" = '[]
-
-_NoGradient ::
-            forall args . Fullfilled "_NoGradient(symbol)" args =>
-              String -> ArgsHMap "_NoGradient(symbol)" args -> IO SymbolHandle
-_NoGradient name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_NoGradient"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CachedOp(symbol)" = '[]
-
-_CachedOp ::
-          forall args . Fullfilled "_CachedOp(symbol)" args =>
-            String -> ArgsHMap "_CachedOp(symbol)" args -> IO SymbolHandle
-_CachedOp name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CachedOp"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_CachedOp(symbol)" = '[]
-
-_backward_CachedOp ::
-                   forall args . Fullfilled "_backward_CachedOp(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_CachedOp(symbol)" args -> IO SymbolHandle
-_backward_CachedOp name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CachedOp"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SwapAxis(symbol)" =
-     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle)]
-
-_SwapAxis ::
-          forall args . Fullfilled "_SwapAxis(symbol)" args =>
-            String -> ArgsHMap "_SwapAxis(symbol)" args -> IO SymbolHandle
-_SwapAxis name args
-  = let scalarArgs
-          = catMaybes
-              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),
-               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SwapAxis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Pad(symbol)" =
-     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),
-        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),
-        '("data", AttrOpt SymbolHandle)]
-
-_Pad ::
-     forall args . Fullfilled "_Pad(symbol)" args =>
-       String -> ArgsHMap "_Pad(symbol)" args -> IO SymbolHandle
-_Pad name args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["constant", "edge", "reflect"])),
-               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),
-               ("constant_value",) . showValue <$>
-                 (args !? #constant_value :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pad"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BatchNorm_v1(symbol)" =
-     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle),
-        '("beta", AttrOpt SymbolHandle)]
-
-_BatchNorm_v1 ::
-              forall args . Fullfilled "_BatchNorm_v1(symbol)" args =>
-                String -> ArgsHMap "_BatchNorm_v1(symbol)" args -> IO SymbolHandle
-_BatchNorm_v1 name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sgd_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)]
-
-sgd_update ::
-           forall args . Fullfilled "sgd_update(symbol)" args =>
-             String -> ArgsHMap "sgd_update(symbol)" args -> IO SymbolHandle
-sgd_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sgd_mom_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mom", AttrOpt SymbolHandle)]
-
-sgd_mom_update ::
-               forall args . Fullfilled "sgd_mom_update(symbol)" args =>
-                 String -> ArgsHMap "sgd_mom_update(symbol)" args -> IO SymbolHandle
-sgd_mom_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_mom_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "mp_sgd_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("weight32", AttrOpt SymbolHandle)]
-
-mp_sgd_update ::
-              forall args . Fullfilled "mp_sgd_update(symbol)" args =>
-                String -> ArgsHMap "mp_sgd_update(symbol)" args -> IO SymbolHandle
-mp_sgd_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "mp_sgd_mom_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mom", AttrOpt SymbolHandle),
-        '("weight32", AttrOpt SymbolHandle)]
-
-mp_sgd_mom_update ::
-                  forall args . Fullfilled "mp_sgd_mom_update(symbol)" args =>
-                    String ->
-                      ArgsHMap "mp_sgd_mom_update(symbol)" args -> IO SymbolHandle
-mp_sgd_mom_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_mom_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "adam_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle)]
-
-adam_update ::
-            forall args . Fullfilled "adam_update(symbol)" args =>
-              String -> ArgsHMap "adam_update(symbol)" args -> IO SymbolHandle
-adam_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mean",) <$> (args !? #mean :: Maybe SymbolHandle),
-               ("var",) <$> (args !? #var :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "adam_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rmsprop_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("n", AttrOpt SymbolHandle)]
-
-rmsprop_update ::
-               forall args . Fullfilled "rmsprop_update(symbol)" args =>
-                 String -> ArgsHMap "rmsprop_update(symbol)" args -> IO SymbolHandle
-rmsprop_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmsprop_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rmspropalex_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("n", AttrOpt SymbolHandle), '("g", AttrOpt SymbolHandle),
-        '("delta", AttrOpt SymbolHandle)]
-
-rmspropalex_update ::
-                   forall args . Fullfilled "rmspropalex_update(symbol)" args =>
-                     String ->
-                       ArgsHMap "rmspropalex_update(symbol)" args -> IO SymbolHandle
-rmspropalex_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("n",) <$> (args !? #n :: Maybe SymbolHandle),
-               ("g",) <$> (args !? #g :: Maybe SymbolHandle),
-               ("delta",) <$> (args !? #delta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmspropalex_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ftrl_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),
-        '("beta", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("z", AttrOpt SymbolHandle), '("n", AttrOpt SymbolHandle)]
-
-ftrl_update ::
-            forall args . Fullfilled "ftrl_update(symbol)" args =>
-              String -> ArgsHMap "ftrl_update(symbol)" args -> IO SymbolHandle
-ftrl_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("z",) <$> (args !? #z :: Maybe SymbolHandle),
-               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftrl_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LeakyReLU(symbol)" =
-     '[ '("act_type",
-          AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu"])),
-        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),
-        '("upper_bound", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_LeakyReLU ::
-           forall args . Fullfilled "_LeakyReLU(symbol)" args =>
-             String -> ArgsHMap "_LeakyReLU(symbol)" args -> IO SymbolHandle
-_LeakyReLU name args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu"])),
-               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),
-               ("lower_bound",) . showValue <$>
-                 (args !? #lower_bound :: Maybe Float),
-               ("upper_bound",) . showValue <$>
-                 (args !? #upper_bound :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LeakyReLU"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_IdentityAttachKLSparseReg(symbol)" =
-     '[ '("sparseness_target", AttrOpt Float),
-        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_IdentityAttachKLSparseReg ::
-                           forall args .
-                             Fullfilled "_IdentityAttachKLSparseReg(symbol)" args =>
-                             String ->
-                               ArgsHMap "_IdentityAttachKLSparseReg(symbol)" args ->
-                                 IO SymbolHandle
-_IdentityAttachKLSparseReg name args
-  = let scalarArgs
-          = catMaybes
-              [("sparseness_target",) . showValue <$>
-                 (args !? #sparseness_target :: Maybe Float),
-               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_UpSampling(symbol)" =
-     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),
-        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),
-        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),
-        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-_UpSampling ::
-            forall args . Fullfilled "_UpSampling(symbol)" args =>
-              String -> ArgsHMap "_UpSampling(symbol)" args -> IO SymbolHandle
-_UpSampling name args
-  = let scalarArgs
-          = catMaybes
-              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("sample_type",) . showValue <$>
-                 (args !? #sample_type ::
-                    Maybe (EnumType '["bilinear", "nearest"])),
-               ("multi_input_mode",) . showValue <$>
-                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "UpSampling"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_SliceChannel(symbol)" =
-     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),
-        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-_SliceChannel ::
-              forall args . Fullfilled "_SliceChannel(symbol)" args =>
-                String -> ArgsHMap "_SliceChannel(symbol)" args -> IO SymbolHandle
-_SliceChannel name args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SliceChannel"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CuDNNBatchNorm(symbol)" =
-     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-_CuDNNBatchNorm ::
-                forall args . Fullfilled "_CuDNNBatchNorm(symbol)" args =>
-                  String ->
-                    ArgsHMap "_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle
-_CuDNNBatchNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CuDNNBatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "softmax_cross_entropy(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-softmax_cross_entropy ::
-                      forall args . Fullfilled "softmax_cross_entropy(symbol)" args =>
-                        String ->
-                          ArgsHMap "softmax_cross_entropy(symbol)" args -> IO SymbolHandle
-softmax_cross_entropy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax_cross_entropy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_softmax_cross_entropy(symbol)" = '[]
-
-_backward_softmax_cross_entropy ::
-                                forall args .
-                                  Fullfilled "_backward_softmax_cross_entropy(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_backward_softmax_cross_entropy(symbol)" args ->
-                                      IO SymbolHandle
-_backward_softmax_cross_entropy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Concat(symbol)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-_Concat ::
-        forall args . Fullfilled "_Concat(symbol)" args =>
-          String -> ArgsHMap "_Concat(symbol)" args -> IO SymbolHandle
-_Concat name args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "Concat"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_BatchNorm(symbol)" =
-     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),
-        '("moving_mean", AttrOpt SymbolHandle),
-        '("moving_var", AttrOpt SymbolHandle)]
-
-_BatchNorm ::
-           forall args . Fullfilled "_BatchNorm(symbol)" args =>
-             String -> ArgsHMap "_BatchNorm(symbol)" args -> IO SymbolHandle
-_BatchNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CustomFunction(symbol)" = '[]
-
-_CustomFunction ::
-                forall args . Fullfilled "_CustomFunction(symbol)" args =>
-                  String ->
-                    ArgsHMap "_CustomFunction(symbol)" args -> IO SymbolHandle
-_CustomFunction name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CustomFunction"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_CustomFunction(symbol)" =
-     '[]
-
-_backward_CustomFunction ::
-                         forall args . Fullfilled "_backward_CustomFunction(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_CustomFunction(symbol)" args -> IO SymbolHandle
-_backward_CustomFunction name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CustomFunction"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiBoxTarget(symbol)" =
-     '[ '("overlap_threshold", AttrOpt Float),
-        '("ignore_label", AttrOpt Float),
-        '("negative_mining_ratio", AttrOpt Float),
-        '("negative_mining_thresh", AttrOpt Float),
-        '("minimum_negative_samples", AttrOpt Int),
-        '("variances", AttrOpt [Float]), '("anchor", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle),
-        '("cls_pred", AttrOpt SymbolHandle)]
-
-_contrib_MultiBoxTarget ::
-                        forall args . Fullfilled "_contrib_MultiBoxTarget(symbol)" args =>
-                          String ->
-                            ArgsHMap "_contrib_MultiBoxTarget(symbol)" args -> IO SymbolHandle
-_contrib_MultiBoxTarget name args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_threshold",) . showValue <$>
-                 (args !? #overlap_threshold :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("negative_mining_ratio",) . showValue <$>
-                 (args !? #negative_mining_ratio :: Maybe Float),
-               ("negative_mining_thresh",) . showValue <$>
-                 (args !? #negative_mining_thresh :: Maybe Float),
-               ("minimum_negative_samples",) . showValue <$>
-                 (args !? #minimum_negative_samples :: Maybe Int),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle),
-               ("cls_pred",) <$> (args !? #cls_pred :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxTarget(symbol)" = '[]
-
-_backward__contrib_MultiBoxTarget ::
-                                  forall args .
-                                    Fullfilled "_backward__contrib_MultiBoxTarget(symbol)" args =>
-                                    String ->
-                                      ArgsHMap "_backward__contrib_MultiBoxTarget(symbol)" args ->
-                                        IO SymbolHandle
-_backward__contrib_MultiBoxTarget name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_Proposal(symbol)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_score", AttrOpt SymbolHandle),
-        '("bbox_pred", AttrOpt SymbolHandle),
-        '("im_info", AttrOpt SymbolHandle)]
-
-_contrib_Proposal ::
-                  forall args . Fullfilled "_contrib_Proposal(symbol)" args =>
-                    String ->
-                      ArgsHMap "_contrib_Proposal(symbol)" args -> IO SymbolHandle
-_contrib_Proposal name args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("cls_score",) <$> (args !? #cls_score :: Maybe SymbolHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_Proposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__contrib_Proposal(symbol)" =
-     '[]
-
-_backward__contrib_Proposal ::
-                            forall args .
-                              Fullfilled "_backward__contrib_Proposal(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward__contrib_Proposal(symbol)" args ->
-                                  IO SymbolHandle
-_backward__contrib_Proposal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_Proposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_count_sketch(symbol)" =
-     '[ '("out_dim", AttrReq Int),
-        '("processing_batch_size", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle), '("h", AttrOpt SymbolHandle),
-        '("s", AttrOpt SymbolHandle)]
-
-_contrib_count_sketch ::
-                      forall args . Fullfilled "_contrib_count_sketch(symbol)" args =>
-                        String ->
-                          ArgsHMap "_contrib_count_sketch(symbol)" args -> IO SymbolHandle
-_contrib_count_sketch name args
-  = let scalarArgs
-          = catMaybes
-              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),
-               ("processing_batch_size",) . showValue <$>
-                 (args !? #processing_batch_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("h",) <$> (args !? #h :: Maybe SymbolHandle),
-               ("s",) <$> (args !? #s :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_count_sketch"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_count_sketch(symbol)" = '[]
-
-_backward__contrib_count_sketch ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_count_sketch(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_backward__contrib_count_sketch(symbol)" args ->
-                                      IO SymbolHandle
-_backward__contrib_count_sketch name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_count_sketch"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiBoxDetection(symbol)" =
-     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),
-        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),
-        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),
-        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt SymbolHandle),
-        '("loc_pred", AttrOpt SymbolHandle),
-        '("anchor", AttrOpt SymbolHandle)]
-
-_contrib_MultiBoxDetection ::
-                           forall args .
-                             Fullfilled "_contrib_MultiBoxDetection(symbol)" args =>
-                             String ->
-                               ArgsHMap "_contrib_MultiBoxDetection(symbol)" args ->
-                                 IO SymbolHandle
-_contrib_MultiBoxDetection name args
-  = let scalarArgs
-          = catMaybes
-              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("nms_threshold",) . showValue <$>
-                 (args !? #nms_threshold :: Maybe Float),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float]),
-               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),
-               ("loc_pred",) <$> (args !? #loc_pred :: Maybe SymbolHandle),
-               ("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxDetection(symbol)" = '[]
-
-_backward__contrib_MultiBoxDetection ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiBoxDetection(symbol)"
-                                         args =>
-                                       String ->
-                                         ArgsHMap "_backward__contrib_MultiBoxDetection(symbol)"
-                                           args
-                                           -> IO SymbolHandle
-_backward__contrib_MultiBoxDetection name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_PSROIPooling(symbol)" =
-     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),
-        '("pooled_size", AttrReq Int), '("group_size", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)]
-
-_contrib_PSROIPooling ::
-                      forall args . Fullfilled "_contrib_PSROIPooling(symbol)" args =>
-                        String ->
-                          ArgsHMap "_contrib_PSROIPooling(symbol)" args -> IO SymbolHandle
-_contrib_PSROIPooling name args
-  = let scalarArgs
-          = catMaybes
-              [("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe Int),
-               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_PSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_PSROIPooling(symbol)" = '[]
-
-_backward__contrib_PSROIPooling ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_PSROIPooling(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_backward__contrib_PSROIPooling(symbol)" args ->
-                                      IO SymbolHandle
-_backward__contrib_PSROIPooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_contrib_DeformablePSROIPooling(symbol)" =
-     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),
-        '("group_size", AttrReq Int), '("pooled_size", AttrReq Int),
-        '("part_size", AttrOpt Int), '("sample_per_part", AttrOpt Int),
-        '("trans_std", AttrOpt Float), '("no_trans", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle),
-        '("trans", AttrOpt SymbolHandle)]
-
-_contrib_DeformablePSROIPooling ::
-                                forall args .
-                                  Fullfilled "_contrib_DeformablePSROIPooling(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_contrib_DeformablePSROIPooling(symbol)" args ->
-                                      IO SymbolHandle
-_contrib_DeformablePSROIPooling name args
-  = let scalarArgs
-          = catMaybes
-              [("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int),
-               ("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe Int),
-               ("part_size",) . showValue <$> (args !? #part_size :: Maybe Int),
-               ("sample_per_part",) . showValue <$>
-                 (args !? #sample_per_part :: Maybe Int),
-               ("trans_std",) . showValue <$> (args !? #trans_std :: Maybe Float),
-               ("no_trans",) . showValue <$> (args !? #no_trans :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle),
-               ("trans",) <$> (args !? #trans :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformablePSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_DeformablePSROIPooling(symbol)" =
-     '[]
-
-_backward__contrib_DeformablePSROIPooling ::
-                                          forall args .
-                                            Fullfilled
-                                              "_backward__contrib_DeformablePSROIPooling(symbol)"
-                                              args =>
-                                            String ->
-                                              ArgsHMap
-                                                "_backward__contrib_DeformablePSROIPooling(symbol)"
-                                                args
-                                                -> IO SymbolHandle
-_backward__contrib_DeformablePSROIPooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__contrib_CTCLoss(symbol)" =
-     '[]
-
-_backward__contrib_CTCLoss ::
-                           forall args .
-                             Fullfilled "_backward__contrib_CTCLoss(symbol)" args =>
-                             String ->
-                               ArgsHMap "_backward__contrib_CTCLoss(symbol)" args ->
-                                 IO SymbolHandle
-_backward__contrib_CTCLoss name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_CTCLoss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiProposal(symbol)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_score", AttrOpt SymbolHandle),
-        '("bbox_pred", AttrOpt SymbolHandle),
-        '("im_info", AttrOpt SymbolHandle)]
-
-_contrib_MultiProposal ::
-                       forall args . Fullfilled "_contrib_MultiProposal(symbol)" args =>
-                         String ->
-                           ArgsHMap "_contrib_MultiProposal(symbol)" args -> IO SymbolHandle
-_contrib_MultiProposal name args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("cls_score",) <$> (args !? #cls_score :: Maybe SymbolHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiProposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiProposal(symbol)" = '[]
-
-_backward__contrib_MultiProposal ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiProposal(symbol)" args =>
-                                   String ->
-                                     ArgsHMap "_backward__contrib_MultiProposal(symbol)" args ->
-                                       IO SymbolHandle
-_backward__contrib_MultiProposal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiBoxPrior(symbol)" =
-     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),
-        '("offsets", AttrOpt [Float]), '("data", AttrOpt SymbolHandle)]
-
-_contrib_MultiBoxPrior ::
-                       forall args . Fullfilled "_contrib_MultiBoxPrior(symbol)" args =>
-                         String ->
-                           ArgsHMap "_contrib_MultiBoxPrior(symbol)" args -> IO SymbolHandle
-_contrib_MultiBoxPrior name args
-  = let scalarArgs
-          = catMaybes
-              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),
-               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxPrior(symbol)" = '[]
-
-_backward__contrib_MultiBoxPrior ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiBoxPrior(symbol)" args =>
-                                   String ->
-                                     ArgsHMap "_backward__contrib_MultiBoxPrior(symbol)" args ->
-                                       IO SymbolHandle
-_backward__contrib_MultiBoxPrior name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_fft(symbol)" =
-     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-_contrib_fft ::
-             forall args . Fullfilled "_contrib_fft(symbol)" args =>
-               String -> ArgsHMap "_contrib_fft(symbol)" args -> IO SymbolHandle
-_contrib_fft name args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_fft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__contrib_fft(symbol)" = '[]
-
-_backward__contrib_fft ::
-                       forall args . Fullfilled "_backward__contrib_fft(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward__contrib_fft(symbol)" args -> IO SymbolHandle
-_backward__contrib_fft name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_fft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_contrib_DeformableConvolution(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("num_deformable_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),
-        '("data", AttrOpt SymbolHandle), '("offset", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]
-
-_contrib_DeformableConvolution ::
-                               forall args .
-                                 Fullfilled "_contrib_DeformableConvolution(symbol)" args =>
-                                 String ->
-                                   ArgsHMap "_contrib_DeformableConvolution(symbol)" args ->
-                                     IO SymbolHandle
-_contrib_DeformableConvolution name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("num_deformable_group",) . showValue <$>
-                 (args !? #num_deformable_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("offset",) <$> (args !? #offset :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformableConvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_DeformableConvolution(symbol)" =
-     '[]
-
-_backward__contrib_DeformableConvolution ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward__contrib_DeformableConvolution(symbol)"
-                                             args =>
-                                           String ->
-                                             ArgsHMap
-                                               "_backward__contrib_DeformableConvolution(symbol)"
-                                               args
-                                               -> IO SymbolHandle
-_backward__contrib_DeformableConvolution name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_ifft(symbol)" =
-     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-_contrib_ifft ::
-              forall args . Fullfilled "_contrib_ifft(symbol)" args =>
-                String -> ArgsHMap "_contrib_ifft(symbol)" args -> IO SymbolHandle
-_contrib_ifft name args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ifft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__contrib_ifft(symbol)" = '[]
-
-_backward__contrib_ifft ::
-                        forall args . Fullfilled "_backward__contrib_ifft(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward__contrib_ifft(symbol)" args -> IO SymbolHandle
-_backward__contrib_ifft name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_ifft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__Native(symbol)" = '[]
-
-_backward__Native ::
-                  forall args . Fullfilled "_backward__Native(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward__Native(symbol)" args -> IO SymbolHandle
-_backward__Native name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__Native"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__NDArray(symbol)" = '[]
-
-_backward__NDArray ::
-                   forall args . Fullfilled "_backward__NDArray(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward__NDArray(symbol)" args -> IO SymbolHandle
-_backward__NDArray name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__NDArray"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_InstanceNorm(symbol)" =
-     '[ '("eps", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]
-
-_InstanceNorm ::
-              forall args . Fullfilled "_InstanceNorm(symbol)" args =>
-                String -> ArgsHMap "_InstanceNorm(symbol)" args -> IO SymbolHandle
-_InstanceNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "InstanceNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_InstanceNorm(symbol)" = '[]
-
-_backward_InstanceNorm ::
-                       forall args . Fullfilled "_backward_InstanceNorm(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_InstanceNorm(symbol)" args -> IO SymbolHandle
-_backward_InstanceNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_InstanceNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SVMOutput(symbol)" =
-     '[ '("margin", AttrOpt Float),
-        '("regularization_coefficient", AttrOpt Float),
-        '("use_linear", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_SVMOutput ::
-           forall args . Fullfilled "_SVMOutput(symbol)" args =>
-             String -> ArgsHMap "_SVMOutput(symbol)" args -> IO SymbolHandle
-_SVMOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),
-               ("regularization_coefficient",) . showValue <$>
-                 (args !? #regularization_coefficient :: Maybe Float),
-               ("use_linear",) . showValue <$>
-                 (args !? #use_linear :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SVMOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SVMOutput(symbol)" = '[]
-
-_backward_SVMOutput ::
-                    forall args . Fullfilled "_backward_SVMOutput(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_SVMOutput(symbol)" args -> IO SymbolHandle
-_backward_SVMOutput name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SVMOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Pooling(symbol)" =
-     '[ '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
-        '("kernel", AttrReq [Int]),
-        '("pool_type", AttrReq (EnumType '["avg", "max", "sum"])),
-        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-_Pooling ::
-         forall args . Fullfilled "_Pooling(symbol)" args =>
-           String -> ArgsHMap "_Pooling(symbol)" args -> IO SymbolHandle
-_Pooling name args
-  = let scalarArgs
-          = catMaybes
-              [("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Pooling(symbol)" = '[]
-
-_backward_Pooling ::
-                  forall args . Fullfilled "_backward_Pooling(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_Pooling(symbol)" args -> IO SymbolHandle
-_backward_Pooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Convolution_v1(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle)]
-
-_Convolution_v1 ::
-                forall args . Fullfilled "_Convolution_v1(symbol)" args =>
-                  String ->
-                    ArgsHMap "_Convolution_v1(symbol)" args -> IO SymbolHandle
-_Convolution_v1 name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Convolution_v1(symbol)" =
-     '[]
-
-_backward_Convolution_v1 ::
-                         forall args . Fullfilled "_backward_Convolution_v1(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_Convolution_v1(symbol)" args -> IO SymbolHandle
-_backward_Convolution_v1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Crop(symbol)" =
-     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),
-        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),
-        '("data", AttrOpt [SymbolHandle])]
-
-_Crop ::
-      forall args . Fullfilled "_Crop(symbol)" args =>
-        String -> ArgsHMap "_Crop(symbol)" args -> IO SymbolHandle
-_Crop name args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),
-               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),
-               ("center_crop",) . showValue <$>
-                 (args !? #center_crop :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "Crop"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_Crop(symbol)" = '[]
-
-_backward_Crop ::
-               forall args . Fullfilled "_backward_Crop(symbol)" args =>
-                 String -> ArgsHMap "_backward_Crop(symbol)" args -> IO SymbolHandle
-_backward_Crop name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Crop"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SpatialTransformer(symbol)" =
-     '[ '("target_shape", AttrOpt [Int]),
-        '("transform_type", AttrReq (EnumType '["affine"])),
-        '("sampler_type", AttrReq (EnumType '["bilinear"])),
-        '("data", AttrOpt SymbolHandle), '("loc", AttrOpt SymbolHandle)]
-
-_SpatialTransformer ::
-                    forall args . Fullfilled "_SpatialTransformer(symbol)" args =>
-                      String ->
-                        ArgsHMap "_SpatialTransformer(symbol)" args -> IO SymbolHandle
-_SpatialTransformer name args
-  = let scalarArgs
-          = catMaybes
-              [("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine"])),
-               ("sampler_type",) . showValue <$>
-                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("loc",) <$> (args !? #loc :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SpatialTransformer"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SpatialTransformer(symbol)"
-     = '[]
-
-_backward_SpatialTransformer ::
-                             forall args .
-                               Fullfilled "_backward_SpatialTransformer(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_backward_SpatialTransformer(symbol)" args ->
-                                   IO SymbolHandle
-_backward_SpatialTransformer name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SpatialTransformer"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SwapAxis(symbol)" = '[]
-
-_backward_SwapAxis ::
-                   forall args . Fullfilled "_backward_SwapAxis(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_SwapAxis(symbol)" args -> IO SymbolHandle
-_backward_SwapAxis name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SwapAxis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LinearRegressionOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_LinearRegressionOutput ::
-                        forall args . Fullfilled "_LinearRegressionOutput(symbol)" args =>
-                          String ->
-                            ArgsHMap "_LinearRegressionOutput(symbol)" args -> IO SymbolHandle
-_LinearRegressionOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LinearRegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_LinearRegressionOutput(symbol)" = '[]
-
-_backward_LinearRegressionOutput ::
-                                 forall args .
-                                   Fullfilled "_backward_LinearRegressionOutput(symbol)" args =>
-                                   String ->
-                                     ArgsHMap "_backward_LinearRegressionOutput(symbol)" args ->
-                                       IO SymbolHandle
-_backward_LinearRegressionOutput name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LinearRegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_MAERegressionOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_MAERegressionOutput ::
-                     forall args . Fullfilled "_MAERegressionOutput(symbol)" args =>
-                       String ->
-                         ArgsHMap "_MAERegressionOutput(symbol)" args -> IO SymbolHandle
-_MAERegressionOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MAERegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_MAERegressionOutput(symbol)"
-     = '[]
-
-_backward_MAERegressionOutput ::
-                              forall args .
-                                Fullfilled "_backward_MAERegressionOutput(symbol)" args =>
-                                String ->
-                                  ArgsHMap "_backward_MAERegressionOutput(symbol)" args ->
-                                    IO SymbolHandle
-_backward_MAERegressionOutput name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MAERegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LogisticRegressionOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_LogisticRegressionOutput ::
-                          forall args .
-                            Fullfilled "_LogisticRegressionOutput(symbol)" args =>
-                            String ->
-                              ArgsHMap "_LogisticRegressionOutput(symbol)" args ->
-                                IO SymbolHandle
-_LogisticRegressionOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LogisticRegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_LogisticRegressionOutput(symbol)" = '[]
-
-_backward_LogisticRegressionOutput ::
-                                   forall args .
-                                     Fullfilled "_backward_LogisticRegressionOutput(symbol)" args =>
-                                     String ->
-                                       ArgsHMap "_backward_LogisticRegressionOutput(symbol)" args ->
-                                         IO SymbolHandle
-_backward_LogisticRegressionOutput name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LogisticRegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Pad(symbol)" = '[]
-
-_backward_Pad ::
-              forall args . Fullfilled "_backward_Pad(symbol)" args =>
-                String -> ArgsHMap "_backward_Pad(symbol)" args -> IO SymbolHandle
-_backward_Pad name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pad"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SoftmaxOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
-        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle)]
-
-_SoftmaxOutput ::
-               forall args . Fullfilled "_SoftmaxOutput(symbol)" args =>
-                 String -> ArgsHMap "_SoftmaxOutput(symbol)" args -> IO SymbolHandle
-_SoftmaxOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SoftmaxOutput(symbol)" = '[]
-
-_backward_SoftmaxOutput ::
-                        forall args . Fullfilled "_backward_SoftmaxOutput(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_SoftmaxOutput(symbol)" args -> IO SymbolHandle
-_backward_SoftmaxOutput name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Softmax(symbol)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
-        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_Softmax ::
-         forall args . Fullfilled "_Softmax(symbol)" args =>
-           String -> ArgsHMap "_Softmax(symbol)" args -> IO SymbolHandle
-_Softmax name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Softmax(symbol)" = '[]
-
-_backward_Softmax ::
-                  forall args . Fullfilled "_backward_Softmax(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_Softmax(symbol)" args -> IO SymbolHandle
-_backward_Softmax name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SequenceReverse(symbol)" =
-     '[ '("use_sequence_length", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle),
-        '("sequence_length", AttrOpt SymbolHandle)]
-
-_SequenceReverse ::
-                 forall args . Fullfilled "_SequenceReverse(symbol)" args =>
-                   String ->
-                     ArgsHMap "_SequenceReverse(symbol)" args -> IO SymbolHandle
-_SequenceReverse name args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceReverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SequenceReverse(symbol)" =
-     '[]
-
-_backward_SequenceReverse ::
-                          forall args .
-                            Fullfilled "_backward_SequenceReverse(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_SequenceReverse(symbol)" args ->
-                                IO SymbolHandle
-_backward_SequenceReverse name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceReverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_BatchNorm_v1(symbol)" = '[]
-
-_backward_BatchNorm_v1 ::
-                       forall args . Fullfilled "_backward_BatchNorm_v1(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_BatchNorm_v1(symbol)" args -> IO SymbolHandle
-_backward_BatchNorm_v1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SequenceLast(symbol)" =
-     '[ '("use_sequence_length", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle),
-        '("sequence_length", AttrOpt SymbolHandle)]
-
-_SequenceLast ::
-              forall args . Fullfilled "_SequenceLast(symbol)" args =>
-                String -> ArgsHMap "_SequenceLast(symbol)" args -> IO SymbolHandle
-_SequenceLast name args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceLast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SequenceLast(symbol)" = '[]
-
-_backward_SequenceLast ::
-                       forall args . Fullfilled "_backward_SequenceLast(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_SequenceLast(symbol)" args -> IO SymbolHandle
-_backward_SequenceLast name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceLast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Correlation(symbol)" =
-     '[ '("kernel_size", AttrOpt Int),
-        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),
-        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),
-        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt SymbolHandle),
-        '("data2", AttrOpt SymbolHandle)]
-
-_Correlation ::
-             forall args . Fullfilled "_Correlation(symbol)" args =>
-               String -> ArgsHMap "_Correlation(symbol)" args -> IO SymbolHandle
-_Correlation name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel_size",) . showValue <$>
-                 (args !? #kernel_size :: Maybe Int),
-               ("max_displacement",) . showValue <$>
-                 (args !? #max_displacement :: Maybe Int),
-               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),
-               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),
-               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),
-               ("is_multiply",) . showValue <$>
-                 (args !? #is_multiply :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data1",) <$> (args !? #data1 :: Maybe SymbolHandle),
-               ("data2",) <$> (args !? #data2 :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Correlation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Correlation(symbol)" = '[]
-
-_backward_Correlation ::
-                      forall args . Fullfilled "_backward_Correlation(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_Correlation(symbol)" args -> IO SymbolHandle
-_backward_Correlation name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Correlation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_MakeLoss(symbol)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_MakeLoss ::
-          forall args . Fullfilled "_MakeLoss(symbol)" args =>
-            String -> ArgsHMap "_MakeLoss(symbol)" args -> IO SymbolHandle
-_MakeLoss name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MakeLoss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_MakeLoss(symbol)" = '[]
-
-_backward_MakeLoss ::
-                   forall args . Fullfilled "_backward_MakeLoss(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_MakeLoss(symbol)" args -> IO SymbolHandle
-_backward_MakeLoss name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MakeLoss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LRN(symbol)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),
-        '("data", AttrOpt SymbolHandle)]
-
-_LRN ::
-     forall args . Fullfilled "_LRN(symbol)" args =>
-       String -> ArgsHMap "_LRN(symbol)" args -> IO SymbolHandle
-_LRN name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),
-               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LRN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_LRN(symbol)" = '[]
-
-_backward_LRN ::
-              forall args . Fullfilled "_backward_LRN(symbol)" args =>
-                String -> ArgsHMap "_backward_LRN(symbol)" args -> IO SymbolHandle
-_backward_LRN name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LRN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SequenceMask(symbol)" =
-     '[ '("use_sequence_length", AttrOpt Bool),
-        '("value", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("sequence_length", AttrOpt SymbolHandle)]
-
-_SequenceMask ::
-              forall args . Fullfilled "_SequenceMask(symbol)" args =>
-                String -> ArgsHMap "_SequenceMask(symbol)" args -> IO SymbolHandle
-_SequenceMask name args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("value",) . showValue <$> (args !? #value :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceMask"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SequenceMask(symbol)" = '[]
-
-_backward_SequenceMask ::
-                       forall args . Fullfilled "_backward_SequenceMask(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_SequenceMask(symbol)" args -> IO SymbolHandle
-_backward_SequenceMask name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceMask"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_GridGenerator(symbol)" =
-     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),
-        '("target_shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-_GridGenerator ::
-               forall args . Fullfilled "_GridGenerator(symbol)" args =>
-                 String -> ArgsHMap "_GridGenerator(symbol)" args -> IO SymbolHandle
-_GridGenerator name args
-  = let scalarArgs
-          = catMaybes
-              [("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "GridGenerator"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_GridGenerator(symbol)" = '[]
-
-_backward_GridGenerator ::
-                        forall args . Fullfilled "_backward_GridGenerator(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_GridGenerator(symbol)" args -> IO SymbolHandle
-_backward_GridGenerator name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_GridGenerator"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Pooling_v1(symbol)" =
-     '[ '("global_pool", AttrOpt Bool), '("kernel", AttrReq [Int]),
-        '("pool_type", AttrReq (EnumType '["avg", "max", "sum"])),
-        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-_Pooling_v1 ::
-            forall args . Fullfilled "_Pooling_v1(symbol)" args =>
-              String -> ArgsHMap "_Pooling_v1(symbol)" args -> IO SymbolHandle
-_Pooling_v1 name args
-  = let scalarArgs
-          = catMaybes
-              [("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Pooling_v1(symbol)" = '[]
-
-_backward_Pooling_v1 ::
-                     forall args . Fullfilled "_backward_Pooling_v1(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_Pooling_v1(symbol)" args -> IO SymbolHandle
-_backward_Pooling_v1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_LeakyReLU(symbol)" = '[]
-
-_backward_LeakyReLU ::
-                    forall args . Fullfilled "_backward_LeakyReLU(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_LeakyReLU(symbol)" args -> IO SymbolHandle
-_backward_LeakyReLU name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LeakyReLU"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_IdentityAttachKLSparseReg(symbol)" = '[]
-
-_backward_IdentityAttachKLSparseReg ::
-                                    forall args .
-                                      Fullfilled "_backward_IdentityAttachKLSparseReg(symbol)"
-                                        args =>
-                                      String ->
-                                        ArgsHMap "_backward_IdentityAttachKLSparseReg(symbol)" args
-                                          -> IO SymbolHandle
-_backward_IdentityAttachKLSparseReg name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Activation(symbol)" =
-     '[ '("act_type",
-          AttrReq (EnumType '["relu", "sigmoid", "softrelu", "tanh"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_Activation ::
-            forall args . Fullfilled "_Activation(symbol)" args =>
-              String -> ArgsHMap "_Activation(symbol)" args -> IO SymbolHandle
-_Activation name args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe (EnumType '["relu", "sigmoid", "softrelu", "tanh"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Activation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Activation(symbol)" = '[]
-
-_backward_Activation ::
-                     forall args . Fullfilled "_backward_Activation(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_Activation(symbol)" args -> IO SymbolHandle
-_backward_Activation name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Activation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_UpSampling(symbol)" = '[]
-
-_backward_UpSampling ::
-                     forall args . Fullfilled "_backward_UpSampling(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_UpSampling(symbol)" args -> IO SymbolHandle
-_backward_UpSampling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_UpSampling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Deconvolution(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle)]
-
-_Deconvolution ::
-               forall args . Fullfilled "_Deconvolution(symbol)" args =>
-                 String -> ArgsHMap "_Deconvolution(symbol)" args -> IO SymbolHandle
-_Deconvolution name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Deconvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Deconvolution(symbol)" = '[]
-
-_backward_Deconvolution ::
-                        forall args . Fullfilled "_backward_Deconvolution(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_Deconvolution(symbol)" args -> IO SymbolHandle
-_backward_Deconvolution name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Deconvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BilinearSampler(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("grid", AttrOpt SymbolHandle)]
-
-_BilinearSampler ::
-                 forall args . Fullfilled "_BilinearSampler(symbol)" args =>
-                   String ->
-                     ArgsHMap "_BilinearSampler(symbol)" args -> IO SymbolHandle
-_BilinearSampler name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("grid",) <$> (args !? #grid :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BilinearSampler"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_BilinearSampler(symbol)" =
-     '[]
-
-_backward_BilinearSampler ::
-                          forall args .
-                            Fullfilled "_backward_BilinearSampler(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_BilinearSampler(symbol)" args ->
-                                IO SymbolHandle
-_backward_BilinearSampler name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BilinearSampler"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_ROIPooling(symbol)" =
-     '[ '("pooled_size", AttrReq [Int]),
-        '("spatial_scale", AttrReq Float), '("data", AttrOpt SymbolHandle),
-        '("rois", AttrOpt SymbolHandle)]
-
-_ROIPooling ::
-            forall args . Fullfilled "_ROIPooling(symbol)" args =>
-              String -> ArgsHMap "_ROIPooling(symbol)" args -> IO SymbolHandle
-_ROIPooling name args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_ROIPooling(symbol)" = '[]
-
-_backward_ROIPooling ::
-                     forall args . Fullfilled "_backward_ROIPooling(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_ROIPooling(symbol)" args -> IO SymbolHandle
-_backward_ROIPooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SliceChannel(symbol)" = '[]
-
-_backward_SliceChannel ::
-                       forall args . Fullfilled "_backward_SliceChannel(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_SliceChannel(symbol)" args -> IO SymbolHandle
-_backward_SliceChannel name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SliceChannel"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_CuDNNBatchNorm(symbol)" =
-     '[]
-
-_backward_CuDNNBatchNorm ::
-                         forall args . Fullfilled "_backward_CuDNNBatchNorm(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle
-_backward_CuDNNBatchNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_FullyConnected(symbol)" =
-     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
-        '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]
-
-_FullyConnected ::
-                forall args . Fullfilled "_FullyConnected(symbol)" args =>
-                  String ->
-                    ArgsHMap "_FullyConnected(symbol)" args -> IO SymbolHandle
-_FullyConnected name args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "FullyConnected"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_FullyConnected(symbol)" =
-     '[]
-
-_backward_FullyConnected ::
-                         forall args . Fullfilled "_backward_FullyConnected(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_FullyConnected(symbol)" args -> IO SymbolHandle
-_backward_FullyConnected name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_FullyConnected"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Convolution(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle)]
-
-_Convolution ::
-             forall args . Fullfilled "_Convolution(symbol)" args =>
-               String -> ArgsHMap "_Convolution(symbol)" args -> IO SymbolHandle
-_Convolution name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Convolution(symbol)" = '[]
-
-_backward_Convolution ::
-                      forall args . Fullfilled "_backward_Convolution(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_Convolution(symbol)" args -> IO SymbolHandle
-_backward_Convolution name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_L2Normalization(symbol)" =
-     '[ '("eps", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_L2Normalization ::
-                 forall args . Fullfilled "_L2Normalization(symbol)" args =>
-                   String ->
-                     ArgsHMap "_L2Normalization(symbol)" args -> IO SymbolHandle
-_L2Normalization name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["channel", "instance", "spatial"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "L2Normalization"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_L2Normalization(symbol)" =
-     '[]
-
-_backward_L2Normalization ::
-                          forall args .
-                            Fullfilled "_backward_L2Normalization(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_L2Normalization(symbol)" args ->
-                                IO SymbolHandle
-_backward_L2Normalization name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_L2Normalization"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Concat(symbol)" = '[]
-
-_backward_Concat ::
-                 forall args . Fullfilled "_backward_Concat(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_Concat(symbol)" args -> IO SymbolHandle
-_backward_Concat name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Concat"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_RNN(symbol)" =
-     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),
-        '("bidirectional", AttrOpt Bool),
-        '("mode",
-          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle),
-        '("parameters", AttrOpt SymbolHandle),
-        '("state", AttrOpt SymbolHandle),
-        '("state_cell", AttrOpt SymbolHandle)]
-
-_RNN ::
-     forall args . Fullfilled "_RNN(symbol)" args =>
-       String -> ArgsHMap "_RNN(symbol)" args -> IO SymbolHandle
-_RNN name args
-  = let scalarArgs
-          = catMaybes
-              [("state_size",) . showValue <$>
-                 (args !? #state_size :: Maybe Int),
-               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),
-               ("bidirectional",) . showValue <$>
-                 (args !? #bidirectional :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("state_outputs",) . showValue <$>
-                 (args !? #state_outputs :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("parameters",) <$> (args !? #parameters :: Maybe SymbolHandle),
-               ("state",) <$> (args !? #state :: Maybe SymbolHandle),
-               ("state_cell",) <$> (args !? #state_cell :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "RNN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_RNN(symbol)" = '[]
-
-_backward_RNN ::
-              forall args . Fullfilled "_backward_RNN(symbol)" args =>
-                String -> ArgsHMap "_backward_RNN(symbol)" args -> IO SymbolHandle
-_backward_RNN name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_RNN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_BatchNorm(symbol)" = '[]
-
-_backward_BatchNorm ::
-                    forall args . Fullfilled "_backward_BatchNorm(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_BatchNorm(symbol)" args -> IO SymbolHandle
-_backward_BatchNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Dropout(symbol)" =
-     '[ '("p", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["always", "training"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_Dropout ::
-         forall args . Fullfilled "_Dropout(symbol)" args =>
-           String -> ArgsHMap "_Dropout(symbol)" args -> IO SymbolHandle
-_Dropout name args
-  = let scalarArgs
-          = catMaybes
-              [("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["always", "training"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Dropout"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Dropout(symbol)" = '[]
-
-_backward_Dropout ::
-                  forall args . Fullfilled "_backward_Dropout(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_Dropout(symbol)" args -> IO SymbolHandle
-_backward_Dropout name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Dropout"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CrossDeviceCopy(symbol)" = '[]
-
-_CrossDeviceCopy ::
-                 forall args . Fullfilled "_CrossDeviceCopy(symbol)" args =>
-                   String ->
-                     ArgsHMap "_CrossDeviceCopy(symbol)" args -> IO SymbolHandle
-_CrossDeviceCopy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CrossDeviceCopy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__CrossDeviceCopy(symbol)" =
-     '[]
-
-_backward__CrossDeviceCopy ::
-                           forall args .
-                             Fullfilled "_backward__CrossDeviceCopy(symbol)" args =>
-                             String ->
-                               ArgsHMap "_backward__CrossDeviceCopy(symbol)" args ->
-                                 IO SymbolHandle
-_backward__CrossDeviceCopy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SoftmaxActivation(symbol)" =
-     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_SoftmaxActivation ::
-                   forall args . Fullfilled "_SoftmaxActivation(symbol)" args =>
-                     String ->
-                       ArgsHMap "_SoftmaxActivation(symbol)" args -> IO SymbolHandle
-_SoftmaxActivation name args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxActivation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SoftmaxActivation(symbol)" =
-     '[]
-
-_backward_SoftmaxActivation ::
-                            forall args .
-                              Fullfilled "_backward_SoftmaxActivation(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_SoftmaxActivation(symbol)" args ->
-                                  IO SymbolHandle
-_backward_SoftmaxActivation name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxActivation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_set_value(symbol)" =
-     '[ '("src", AttrOpt Float)]
-
-_set_value ::
-           forall args . Fullfilled "_set_value(symbol)" args =>
-             String -> ArgsHMap "_set_value(symbol)" args -> IO SymbolHandle
-_set_value name args
-  = let scalarArgs
-          = catMaybes
-              [("src",) . showValue <$> (args !? #src :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_set_value"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_imdecode(symbol)" =
-     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),
-        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),
-        '("c", AttrOpt Int), '("size", AttrOpt Int),
-        '("mean", AttrOpt SymbolHandle)]
-
-_imdecode ::
-          forall args . Fullfilled "_imdecode(symbol)" args =>
-            String -> ArgsHMap "_imdecode(symbol)" args -> IO SymbolHandle
-_imdecode name args
-  = let scalarArgs
-          = catMaybes
-              [("index",) . showValue <$> (args !? #index :: Maybe Int),
-               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),
-               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),
-               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),
-               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),
-               ("c",) . showValue <$> (args !? #c :: Maybe Int),
-               ("size",) . showValue <$> (args !? #size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("mean",) <$> (args !? #mean :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_imdecode"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
diff --git a/ops/1.3/MXNet/Base/Operators/NDArray.hs b/ops/1.3/MXNet/Base/Operators/NDArray.hs
deleted file mode 100644
--- a/ops/1.3/MXNet/Base/Operators/NDArray.hs
+++ /dev/null
@@ -1,20011 +0,0 @@
-module MXNet.Base.Operators.NDArray where
-import MXNet.Base.Raw
-import MXNet.Base.Spec.Operator
-import MXNet.Base.Spec.HMap
-import Data.Maybe (catMaybes, fromMaybe)
-
-type instance ParameterList "_sample_multinomial(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_sample_multinomial ::
-                    forall args . Fullfilled "_sample_multinomial(ndarray)" args =>
-                      ArgsHMap "_sample_multinomial(ndarray)" args -> IO [NDArrayHandle]
-_sample_multinomial args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_multinomial_upd ::
-                        forall args . Fullfilled "_sample_multinomial(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_sample_multinomial(ndarray)" args -> IO ()
-_sample_multinomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sample_multinomial(ndarray)"
-     = '[]
-
-_backward_sample_multinomial ::
-                             forall args .
-                               Fullfilled "_backward_sample_multinomial(ndarray)" args =>
-                               ArgsHMap "_backward_sample_multinomial(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_backward_sample_multinomial args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sample_multinomial_upd ::
-                                 forall args .
-                                   Fullfilled "_backward_sample_multinomial(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_backward_sample_multinomial(ndarray)" args -> IO ()
-_backward_sample_multinomial_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_uniform(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("low", AttrOpt NDArrayHandle), '("high", AttrOpt NDArrayHandle)]
-
-_sample_uniform ::
-                forall args . Fullfilled "_sample_uniform(ndarray)" args =>
-                  ArgsHMap "_sample_uniform(ndarray)" args -> IO [NDArrayHandle]
-_sample_uniform args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("low",) <$> (args !? #low :: Maybe NDArrayHandle),
-               ("high",) <$> (args !? #high :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_uniform_upd ::
-                    forall args . Fullfilled "_sample_uniform(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_sample_uniform(ndarray)" args -> IO ()
-_sample_uniform_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("low",) <$> (args !? #low :: Maybe NDArrayHandle),
-               ("high",) <$> (args !? #high :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_normal(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt NDArrayHandle), '("sigma", AttrOpt NDArrayHandle)]
-
-_sample_normal ::
-               forall args . Fullfilled "_sample_normal(ndarray)" args =>
-                 ArgsHMap "_sample_normal(ndarray)" args -> IO [NDArrayHandle]
-_sample_normal args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_normal_upd ::
-                   forall args . Fullfilled "_sample_normal(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_sample_normal(ndarray)" args -> IO ()
-_sample_normal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_gamma(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("alpha", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_sample_gamma ::
-              forall args . Fullfilled "_sample_gamma(ndarray)" args =>
-                ArgsHMap "_sample_gamma(ndarray)" args -> IO [NDArrayHandle]
-_sample_gamma args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_gamma_upd ::
-                  forall args . Fullfilled "_sample_gamma(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_sample_gamma(ndarray)" args -> IO ()
-_sample_gamma_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_exponential(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt NDArrayHandle)]
-
-_sample_exponential ::
-                    forall args . Fullfilled "_sample_exponential(ndarray)" args =>
-                      ArgsHMap "_sample_exponential(ndarray)" args -> IO [NDArrayHandle]
-_sample_exponential args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_exponential_upd ::
-                        forall args . Fullfilled "_sample_exponential(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_sample_exponential(ndarray)" args -> IO ()
-_sample_exponential_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_poisson(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt NDArrayHandle)]
-
-_sample_poisson ::
-                forall args . Fullfilled "_sample_poisson(ndarray)" args =>
-                  ArgsHMap "_sample_poisson(ndarray)" args -> IO [NDArrayHandle]
-_sample_poisson args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_poisson_upd ::
-                    forall args . Fullfilled "_sample_poisson(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_sample_poisson(ndarray)" args -> IO ()
-_sample_poisson_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_negative_binomial(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("k", AttrOpt NDArrayHandle), '("p", AttrOpt NDArrayHandle)]
-
-_sample_negative_binomial ::
-                          forall args .
-                            Fullfilled "_sample_negative_binomial(ndarray)" args =>
-                            ArgsHMap "_sample_negative_binomial(ndarray)" args ->
-                              IO [NDArrayHandle]
-_sample_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("k",) <$> (args !? #k :: Maybe NDArrayHandle),
-               ("p",) <$> (args !? #p :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_negative_binomial_upd ::
-                              forall args .
-                                Fullfilled "_sample_negative_binomial(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_sample_negative_binomial(ndarray)" args -> IO ()
-_sample_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("k",) <$> (args !? #k :: Maybe NDArrayHandle),
-               ("p",) <$> (args !? #p :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_sample_generalized_negative_binomial(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt NDArrayHandle), '("alpha", AttrOpt NDArrayHandle)]
-
-_sample_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_sample_generalized_negative_binomial(ndarray)"
-                                          args =>
-                                        ArgsHMap "_sample_generalized_negative_binomial(ndarray)"
-                                          args
-                                          -> IO [NDArrayHandle]
-_sample_generalized_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_generalized_negative_binomial_upd ::
-                                          forall args .
-                                            Fullfilled
-                                              "_sample_generalized_negative_binomial(ndarray)"
-                                              args =>
-                                            [NDArrayHandle] ->
-                                              ArgsHMap
-                                                "_sample_generalized_negative_binomial(ndarray)"
-                                                args
-                                                -> IO ()
-_sample_generalized_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_unique_zipfian(ndarray)" =
-     '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])]
-
-_sample_unique_zipfian ::
-                       forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args =>
-                         ArgsHMap "_sample_unique_zipfian(ndarray)" args ->
-                           IO [NDArrayHandle]
-_sample_unique_zipfian args
-  = let scalarArgs
-          = catMaybes
-              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_unique_zipfian"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_unique_zipfian_upd ::
-                           forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_sample_unique_zipfian(ndarray)" args -> IO ()
-_sample_unique_zipfian_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_unique_zipfian"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_uniform(ndarray)" =
-     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_uniform ::
-                forall args . Fullfilled "_random_uniform(ndarray)" args =>
-                  ArgsHMap "_random_uniform(ndarray)" args -> IO [NDArrayHandle]
-_random_uniform args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_uniform_upd ::
-                    forall args . Fullfilled "_random_uniform(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_random_uniform(ndarray)" args -> IO ()
-_random_uniform_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_normal(ndarray)" =
-     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_normal ::
-               forall args . Fullfilled "_random_normal(ndarray)" args =>
-                 ArgsHMap "_random_normal(ndarray)" args -> IO [NDArrayHandle]
-_random_normal args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_normal_upd ::
-                   forall args . Fullfilled "_random_normal(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_random_normal(ndarray)" args -> IO ()
-_random_normal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_gamma(ndarray)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_gamma ::
-              forall args . Fullfilled "_random_gamma(ndarray)" args =>
-                ArgsHMap "_random_gamma(ndarray)" args -> IO [NDArrayHandle]
-_random_gamma args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_gamma_upd ::
-                  forall args . Fullfilled "_random_gamma(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_random_gamma(ndarray)" args -> IO ()
-_random_gamma_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_exponential(ndarray)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_exponential ::
-                    forall args . Fullfilled "_random_exponential(ndarray)" args =>
-                      ArgsHMap "_random_exponential(ndarray)" args -> IO [NDArrayHandle]
-_random_exponential args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_exponential_upd ::
-                        forall args . Fullfilled "_random_exponential(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_random_exponential(ndarray)" args -> IO ()
-_random_exponential_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_poisson(ndarray)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_poisson ::
-                forall args . Fullfilled "_random_poisson(ndarray)" args =>
-                  ArgsHMap "_random_poisson(ndarray)" args -> IO [NDArrayHandle]
-_random_poisson args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_poisson_upd ::
-                    forall args . Fullfilled "_random_poisson(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_random_poisson(ndarray)" args -> IO ()
-_random_poisson_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_negative_binomial(ndarray)" =
-     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_negative_binomial ::
-                          forall args .
-                            Fullfilled "_random_negative_binomial(ndarray)" args =>
-                            ArgsHMap "_random_negative_binomial(ndarray)" args ->
-                              IO [NDArrayHandle]
-_random_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_negative_binomial_upd ::
-                              forall args .
-                                Fullfilled "_random_negative_binomial(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_random_negative_binomial(ndarray)" args -> IO ()
-_random_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_random_generalized_negative_binomial(ndarray)" =
-     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_random_generalized_negative_binomial(ndarray)"
-                                          args =>
-                                        ArgsHMap "_random_generalized_negative_binomial(ndarray)"
-                                          args
-                                          -> IO [NDArrayHandle]
-_random_generalized_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_generalized_negative_binomial_upd ::
-                                          forall args .
-                                            Fullfilled
-                                              "_random_generalized_negative_binomial(ndarray)"
-                                              args =>
-                                            [NDArrayHandle] ->
-                                              ArgsHMap
-                                                "_random_generalized_negative_binomial(ndarray)"
-                                                args
-                                                -> IO ()
-_random_generalized_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_shuffle(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_shuffle ::
-         forall args . Fullfilled "_shuffle(ndarray)" args =>
-           ArgsHMap "_shuffle(ndarray)" args -> IO [NDArrayHandle]
-_shuffle args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_shuffle"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_shuffle_upd ::
-             forall args . Fullfilled "_shuffle(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_shuffle(ndarray)" args -> IO ()
-_shuffle_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_shuffle"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Custom(ndarray)" = '[]
-
-_backward_Custom ::
-                 forall args . Fullfilled "_backward_Custom(ndarray)" args =>
-                   ArgsHMap "_backward_Custom(ndarray)" args -> IO [NDArrayHandle]
-_backward_Custom args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Custom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Custom_upd ::
-                     forall args . Fullfilled "_backward_Custom(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_Custom(ndarray)" args -> IO ()
-_backward_Custom_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Custom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_power(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_power ::
-                forall args . Fullfilled "broadcast_power(ndarray)" args =>
-                  ArgsHMap "broadcast_power(ndarray)" args -> IO [NDArrayHandle]
-broadcast_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_power_upd ::
-                    forall args . Fullfilled "broadcast_power(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "broadcast_power(ndarray)" args -> IO ()
-broadcast_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_power(ndarray)" =
-     '[]
-
-_backward_broadcast_power ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_power(ndarray)" args =>
-                            ArgsHMap "_backward_broadcast_power(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_broadcast_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_power_upd ::
-                              forall args .
-                                Fullfilled "_backward_broadcast_power(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_broadcast_power(ndarray)" args -> IO ()
-_backward_broadcast_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_maximum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_maximum ::
-                  forall args . Fullfilled "broadcast_maximum(ndarray)" args =>
-                    ArgsHMap "broadcast_maximum(ndarray)" args -> IO [NDArrayHandle]
-broadcast_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_maximum_upd ::
-                      forall args . Fullfilled "broadcast_maximum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "broadcast_maximum(ndarray)" args -> IO ()
-broadcast_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_maximum(ndarray)"
-     = '[]
-
-_backward_broadcast_maximum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_maximum(ndarray)" args =>
-                              ArgsHMap "_backward_broadcast_maximum(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_broadcast_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_maximum_upd ::
-                                forall args .
-                                  Fullfilled "_backward_broadcast_maximum(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> IO ()
-_backward_broadcast_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_minimum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_minimum ::
-                  forall args . Fullfilled "broadcast_minimum(ndarray)" args =>
-                    ArgsHMap "broadcast_minimum(ndarray)" args -> IO [NDArrayHandle]
-broadcast_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_minimum_upd ::
-                      forall args . Fullfilled "broadcast_minimum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "broadcast_minimum(ndarray)" args -> IO ()
-broadcast_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_minimum(ndarray)"
-     = '[]
-
-_backward_broadcast_minimum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_minimum(ndarray)" args =>
-                              ArgsHMap "_backward_broadcast_minimum(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_broadcast_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_minimum_upd ::
-                                forall args .
-                                  Fullfilled "_backward_broadcast_minimum(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> IO ()
-_backward_broadcast_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_hypot(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_hypot ::
-                forall args . Fullfilled "broadcast_hypot(ndarray)" args =>
-                  ArgsHMap "broadcast_hypot(ndarray)" args -> IO [NDArrayHandle]
-broadcast_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_hypot_upd ::
-                    forall args . Fullfilled "broadcast_hypot(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "broadcast_hypot(ndarray)" args -> IO ()
-broadcast_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_hypot(ndarray)" =
-     '[]
-
-_backward_broadcast_hypot ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_hypot(ndarray)" args =>
-                            ArgsHMap "_backward_broadcast_hypot(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_broadcast_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_hypot_upd ::
-                              forall args .
-                                Fullfilled "_backward_broadcast_hypot(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> IO ()
-_backward_broadcast_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_equal ::
-       forall args . Fullfilled "_equal(ndarray)" args =>
-         ArgsHMap "_equal(ndarray)" args -> IO [NDArrayHandle]
-_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_equal_upd ::
-           forall args . Fullfilled "_equal(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_equal(ndarray)" args -> IO ()
-_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_not_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_not_equal ::
-           forall args . Fullfilled "_not_equal(ndarray)" args =>
-             ArgsHMap "_not_equal(ndarray)" args -> IO [NDArrayHandle]
-_not_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_not_equal_upd ::
-               forall args . Fullfilled "_not_equal(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_not_equal(ndarray)" args -> IO ()
-_not_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_greater ::
-         forall args . Fullfilled "_greater(ndarray)" args =>
-           ArgsHMap "_greater(ndarray)" args -> IO [NDArrayHandle]
-_greater args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_upd ::
-             forall args . Fullfilled "_greater(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_greater(ndarray)" args -> IO ()
-_greater_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_greater_equal ::
-               forall args . Fullfilled "_greater_equal(ndarray)" args =>
-                 ArgsHMap "_greater_equal(ndarray)" args -> IO [NDArrayHandle]
-_greater_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_equal_upd ::
-                   forall args . Fullfilled "_greater_equal(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_greater_equal(ndarray)" args -> IO ()
-_greater_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_lesser ::
-        forall args . Fullfilled "_lesser(ndarray)" args =>
-          ArgsHMap "_lesser(ndarray)" args -> IO [NDArrayHandle]
-_lesser args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_upd ::
-            forall args . Fullfilled "_lesser(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_lesser(ndarray)" args -> IO ()
-_lesser_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_lesser_equal ::
-              forall args . Fullfilled "_lesser_equal(ndarray)" args =>
-                ArgsHMap "_lesser_equal(ndarray)" args -> IO [NDArrayHandle]
-_lesser_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_equal_upd ::
-                  forall args . Fullfilled "_lesser_equal(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_lesser_equal(ndarray)" args -> IO ()
-_lesser_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_and(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_logical_and ::
-             forall args . Fullfilled "_logical_and(ndarray)" args =>
-               ArgsHMap "_logical_and(ndarray)" args -> IO [NDArrayHandle]
-_logical_and args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_and_upd ::
-                 forall args . Fullfilled "_logical_and(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_logical_and(ndarray)" args -> IO ()
-_logical_and_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_or(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_logical_or ::
-            forall args . Fullfilled "_logical_or(ndarray)" args =>
-              ArgsHMap "_logical_or(ndarray)" args -> IO [NDArrayHandle]
-_logical_or args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_or_upd ::
-                forall args . Fullfilled "_logical_or(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_logical_or(ndarray)" args -> IO ()
-_logical_or_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_xor(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_logical_xor ::
-             forall args . Fullfilled "_logical_xor(ndarray)" args =>
-               ArgsHMap "_logical_xor(ndarray)" args -> IO [NDArrayHandle]
-_logical_xor args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_xor_upd ::
-                 forall args . Fullfilled "_logical_xor(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_logical_xor(ndarray)" args -> IO ()
-_logical_xor_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_power(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_power ::
-       forall args . Fullfilled "_power(ndarray)" args =>
-         ArgsHMap "_power(ndarray)" args -> IO [NDArrayHandle]
-_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_power_upd ::
-           forall args . Fullfilled "_power(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_power(ndarray)" args -> IO ()
-_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_power(ndarray)" = '[]
-
-_backward_power ::
-                forall args . Fullfilled "_backward_power(ndarray)" args =>
-                  ArgsHMap "_backward_power(ndarray)" args -> IO [NDArrayHandle]
-_backward_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_power_upd ::
-                    forall args . Fullfilled "_backward_power(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_power(ndarray)" args -> IO ()
-_backward_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_maximum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_maximum ::
-         forall args . Fullfilled "_maximum(ndarray)" args =>
-           ArgsHMap "_maximum(ndarray)" args -> IO [NDArrayHandle]
-_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_maximum_upd ::
-             forall args . Fullfilled "_maximum(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_maximum(ndarray)" args -> IO ()
-_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_maximum(ndarray)" = '[]
-
-_backward_maximum ::
-                  forall args . Fullfilled "_backward_maximum(ndarray)" args =>
-                    ArgsHMap "_backward_maximum(ndarray)" args -> IO [NDArrayHandle]
-_backward_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_maximum_upd ::
-                      forall args . Fullfilled "_backward_maximum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_maximum(ndarray)" args -> IO ()
-_backward_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_minimum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_minimum ::
-         forall args . Fullfilled "_minimum(ndarray)" args =>
-           ArgsHMap "_minimum(ndarray)" args -> IO [NDArrayHandle]
-_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_minimum_upd ::
-             forall args . Fullfilled "_minimum(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_minimum(ndarray)" args -> IO ()
-_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_minimum(ndarray)" = '[]
-
-_backward_minimum ::
-                  forall args . Fullfilled "_backward_minimum(ndarray)" args =>
-                    ArgsHMap "_backward_minimum(ndarray)" args -> IO [NDArrayHandle]
-_backward_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_minimum_upd ::
-                      forall args . Fullfilled "_backward_minimum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_minimum(ndarray)" args -> IO ()
-_backward_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_hypot(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_hypot ::
-       forall args . Fullfilled "_hypot(ndarray)" args =>
-         ArgsHMap "_hypot(ndarray)" args -> IO [NDArrayHandle]
-_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_hypot_upd ::
-           forall args . Fullfilled "_hypot(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_hypot(ndarray)" args -> IO ()
-_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_hypot(ndarray)" = '[]
-
-_backward_hypot ::
-                forall args . Fullfilled "_backward_hypot(ndarray)" args =>
-                  ArgsHMap "_backward_hypot(ndarray)" args -> IO [NDArrayHandle]
-_backward_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_hypot_upd ::
-                    forall args . Fullfilled "_backward_hypot(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_hypot(ndarray)" args -> IO ()
-_backward_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_square_sum(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-_square_sum ::
-            forall args . Fullfilled "_square_sum(ndarray)" args =>
-              ArgsHMap "_square_sum(ndarray)" args -> IO [NDArrayHandle]
-_square_sum args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_square_sum_upd ::
-                forall args . Fullfilled "_square_sum(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_square_sum(ndarray)" args -> IO ()
-_square_sum_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_square_sum(ndarray)" = '[]
-
-_backward_square_sum ::
-                     forall args . Fullfilled "_backward_square_sum(ndarray)" args =>
-                       ArgsHMap "_backward_square_sum(ndarray)" args -> IO [NDArrayHandle]
-_backward_square_sum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_square_sum_upd ::
-                         forall args . Fullfilled "_backward_square_sum(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_square_sum(ndarray)" args -> IO ()
-_backward_square_sum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "add_n(ndarray)" =
-     '[ '("args", AttrOpt [NDArrayHandle])]
-
-add_n ::
-      forall args . Fullfilled "add_n(ndarray)" args =>
-        ArgsHMap "add_n(ndarray)" args -> IO [NDArrayHandle]
-add_n args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "add_n"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-add_n_upd ::
-          forall args . Fullfilled "add_n(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "add_n(ndarray)" args -> IO ()
-add_n_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "add_n"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_zeros(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_zeros ::
-       forall args . Fullfilled "_zeros(ndarray)" args =>
-         ArgsHMap "_zeros(ndarray)" args -> IO [NDArrayHandle]
-_zeros args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_zeros_upd ::
-           forall args . Fullfilled "_zeros(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_zeros(ndarray)" args -> IO ()
-_zeros_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_eye(ndarray)" =
-     '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_eye ::
-     forall args . Fullfilled "_eye(ndarray)" args =>
-       ArgsHMap "_eye(ndarray)" args -> IO [NDArrayHandle]
-_eye args
-  = let scalarArgs
-          = catMaybes
-              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),
-               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_eye"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_eye_upd ::
-         forall args . Fullfilled "_eye(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_eye(ndarray)" args -> IO ()
-_eye_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),
-               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_eye"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_ones(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_ones ::
-      forall args . Fullfilled "_ones(ndarray)" args =>
-        ArgsHMap "_ones(ndarray)" args -> IO [NDArrayHandle]
-_ones args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ones"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_ones_upd ::
-          forall args . Fullfilled "_ones(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_ones(ndarray)" args -> IO ()
-_ones_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ones"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_full(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("value", AttrReq Double)]
-
-_full ::
-      forall args . Fullfilled "_full(ndarray)" args =>
-        ArgsHMap "_full(ndarray)" args -> IO [NDArrayHandle]
-_full args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_full"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_full_upd ::
-          forall args . Fullfilled "_full(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_full(ndarray)" args -> IO ()
-_full_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_full"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_arange(ndarray)" =
-     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),
-        '("step", AttrOpt Double), '("repeat", AttrOpt Int),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_arange ::
-        forall args . Fullfilled "_arange(ndarray)" args =>
-          ArgsHMap "_arange(ndarray)" args -> IO [NDArrayHandle]
-_arange args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_arange"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_arange_upd ::
-            forall args . Fullfilled "_arange(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_arange(ndarray)" args -> IO ()
-_arange_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_arange"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "zeros_like(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-zeros_like ::
-           forall args . Fullfilled "zeros_like(ndarray)" args =>
-             ArgsHMap "zeros_like(ndarray)" args -> IO [NDArrayHandle]
-zeros_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "zeros_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-zeros_like_upd ::
-               forall args . Fullfilled "zeros_like(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "zeros_like(ndarray)" args -> IO ()
-zeros_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "zeros_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ones_like(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-ones_like ::
-          forall args . Fullfilled "ones_like(ndarray)" args =>
-            ArgsHMap "ones_like(ndarray)" args -> IO [NDArrayHandle]
-ones_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ones_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ones_like_upd ::
-              forall args . Fullfilled "ones_like(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "ones_like(ndarray)" args -> IO ()
-ones_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ones_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_add(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_add ::
-              forall args . Fullfilled "broadcast_add(ndarray)" args =>
-                ArgsHMap "broadcast_add(ndarray)" args -> IO [NDArrayHandle]
-broadcast_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_add_upd ::
-                  forall args . Fullfilled "broadcast_add(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_add(ndarray)" args -> IO ()
-broadcast_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_add(ndarray)" =
-     '[]
-
-_backward_broadcast_add ::
-                        forall args . Fullfilled "_backward_broadcast_add(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_add(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_add_upd ::
-                            forall args . Fullfilled "_backward_broadcast_add(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_add(ndarray)" args -> IO ()
-_backward_broadcast_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_sub(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_sub ::
-              forall args . Fullfilled "broadcast_sub(ndarray)" args =>
-                ArgsHMap "broadcast_sub(ndarray)" args -> IO [NDArrayHandle]
-broadcast_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_sub_upd ::
-                  forall args . Fullfilled "broadcast_sub(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_sub(ndarray)" args -> IO ()
-broadcast_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_sub(ndarray)" =
-     '[]
-
-_backward_broadcast_sub ::
-                        forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_sub(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_sub_upd ::
-                            forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_sub(ndarray)" args -> IO ()
-_backward_broadcast_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_mul(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_mul ::
-              forall args . Fullfilled "broadcast_mul(ndarray)" args =>
-                ArgsHMap "broadcast_mul(ndarray)" args -> IO [NDArrayHandle]
-broadcast_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_mul_upd ::
-                  forall args . Fullfilled "broadcast_mul(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_mul(ndarray)" args -> IO ()
-broadcast_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_mul(ndarray)" =
-     '[]
-
-_backward_broadcast_mul ::
-                        forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_mul(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_mul_upd ::
-                            forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_mul(ndarray)" args -> IO ()
-_backward_broadcast_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_div(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_div ::
-              forall args . Fullfilled "broadcast_div(ndarray)" args =>
-                ArgsHMap "broadcast_div(ndarray)" args -> IO [NDArrayHandle]
-broadcast_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_div_upd ::
-                  forall args . Fullfilled "broadcast_div(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_div(ndarray)" args -> IO ()
-broadcast_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_div(ndarray)" =
-     '[]
-
-_backward_broadcast_div ::
-                        forall args . Fullfilled "_backward_broadcast_div(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_div(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_div_upd ::
-                            forall args . Fullfilled "_backward_broadcast_div(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_div(ndarray)" args -> IO ()
-_backward_broadcast_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_mod(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_mod ::
-              forall args . Fullfilled "broadcast_mod(ndarray)" args =>
-                ArgsHMap "broadcast_mod(ndarray)" args -> IO [NDArrayHandle]
-broadcast_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_mod_upd ::
-                  forall args . Fullfilled "broadcast_mod(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_mod(ndarray)" args -> IO ()
-broadcast_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_mod(ndarray)" =
-     '[]
-
-_backward_broadcast_mod ::
-                        forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_mod(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_mod_upd ::
-                            forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_mod(ndarray)" args -> IO ()
-_backward_broadcast_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_gemm(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),
-        '("axis", AttrOpt Int), '("_A", AttrOpt NDArrayHandle),
-        '("_B", AttrOpt NDArrayHandle), '("_C", AttrOpt NDArrayHandle)]
-
-_linalg_gemm ::
-             forall args . Fullfilled "_linalg_gemm(ndarray)" args =>
-               ArgsHMap "_linalg_gemm(ndarray)" args -> IO [NDArrayHandle]
-_linalg_gemm args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle),
-               ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_gemm_upd ::
-                 forall args . Fullfilled "_linalg_gemm(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_gemm(ndarray)" args -> IO ()
-_linalg_gemm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle),
-               ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_gemm(ndarray)" = '[]
-
-_backward_linalg_gemm ::
-                      forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_gemm(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_gemm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_gemm_upd ::
-                          forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_gemm(ndarray)" args -> IO ()
-_backward_linalg_gemm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_gemm2(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("axis", AttrOpt Int),
-        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)]
-
-_linalg_gemm2 ::
-              forall args . Fullfilled "_linalg_gemm2(ndarray)" args =>
-                ArgsHMap "_linalg_gemm2(ndarray)" args -> IO [NDArrayHandle]
-_linalg_gemm2 args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_gemm2_upd ::
-                  forall args . Fullfilled "_linalg_gemm2(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_gemm2(ndarray)" args -> IO ()
-_linalg_gemm2_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_gemm2(ndarray)" = '[]
-
-_backward_linalg_gemm2 ::
-                       forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_gemm2(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_gemm2 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_gemm2_upd ::
-                           forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> IO ()
-_backward_linalg_gemm2_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_potrf(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_potrf ::
-              forall args . Fullfilled "_linalg_potrf(ndarray)" args =>
-                ArgsHMap "_linalg_potrf(ndarray)" args -> IO [NDArrayHandle]
-_linalg_potrf args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_potrf_upd ::
-                  forall args . Fullfilled "_linalg_potrf(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_potrf(ndarray)" args -> IO ()
-_linalg_potrf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_potrf(ndarray)" = '[]
-
-_backward_linalg_potrf ::
-                       forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_potrf(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_potrf args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_potrf_upd ::
-                           forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_potrf(ndarray)" args -> IO ()
-_backward_linalg_potrf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_potri(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_potri ::
-              forall args . Fullfilled "_linalg_potri(ndarray)" args =>
-                ArgsHMap "_linalg_potri(ndarray)" args -> IO [NDArrayHandle]
-_linalg_potri args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_potri_upd ::
-                  forall args . Fullfilled "_linalg_potri(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_potri(ndarray)" args -> IO ()
-_linalg_potri_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_potri(ndarray)" = '[]
-
-_backward_linalg_potri ::
-                       forall args . Fullfilled "_backward_linalg_potri(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_potri(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_potri args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_potri_upd ::
-                           forall args . Fullfilled "_backward_linalg_potri(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_potri(ndarray)" args -> IO ()
-_backward_linalg_potri_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_trmm(ndarray)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("_A", AttrOpt NDArrayHandle),
-        '("_B", AttrOpt NDArrayHandle)]
-
-_linalg_trmm ::
-             forall args . Fullfilled "_linalg_trmm(ndarray)" args =>
-               ArgsHMap "_linalg_trmm(ndarray)" args -> IO [NDArrayHandle]
-_linalg_trmm args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_trmm_upd ::
-                 forall args . Fullfilled "_linalg_trmm(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_trmm(ndarray)" args -> IO ()
-_linalg_trmm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_trmm(ndarray)" = '[]
-
-_backward_linalg_trmm ::
-                      forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_trmm(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_trmm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_trmm_upd ::
-                          forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_trmm(ndarray)" args -> IO ()
-_backward_linalg_trmm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_trsm(ndarray)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("_A", AttrOpt NDArrayHandle),
-        '("_B", AttrOpt NDArrayHandle)]
-
-_linalg_trsm ::
-             forall args . Fullfilled "_linalg_trsm(ndarray)" args =>
-               ArgsHMap "_linalg_trsm(ndarray)" args -> IO [NDArrayHandle]
-_linalg_trsm args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_trsm_upd ::
-                 forall args . Fullfilled "_linalg_trsm(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_trsm(ndarray)" args -> IO ()
-_linalg_trsm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_trsm(ndarray)" = '[]
-
-_backward_linalg_trsm ::
-                      forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_trsm(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_trsm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_trsm_upd ::
-                          forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_trsm(ndarray)" args -> IO ()
-_backward_linalg_trsm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_sumlogdiag(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_sumlogdiag ::
-                   forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args =>
-                     ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO [NDArrayHandle]
-_linalg_sumlogdiag args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_sumlogdiag_upd ::
-                       forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO ()
-_linalg_sumlogdiag_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_sumlogdiag(ndarray)"
-     = '[]
-
-_backward_linalg_sumlogdiag ::
-                            forall args .
-                              Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args =>
-                              ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_linalg_sumlogdiag args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_sumlogdiag_upd ::
-                                forall args .
-                                  Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> IO ()
-_backward_linalg_sumlogdiag_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_syrk(ndarray)" =
-     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_syrk ::
-             forall args . Fullfilled "_linalg_syrk(ndarray)" args =>
-               ArgsHMap "_linalg_syrk(ndarray)" args -> IO [NDArrayHandle]
-_linalg_syrk args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_syrk_upd ::
-                 forall args . Fullfilled "_linalg_syrk(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_syrk(ndarray)" args -> IO ()
-_linalg_syrk_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_syrk(ndarray)" = '[]
-
-_backward_linalg_syrk ::
-                      forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_syrk(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_syrk args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_syrk_upd ::
-                          forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_syrk(ndarray)" args -> IO ()
-_backward_linalg_syrk_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_gelqf(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_gelqf ::
-              forall args . Fullfilled "_linalg_gelqf(ndarray)" args =>
-                ArgsHMap "_linalg_gelqf(ndarray)" args -> IO [NDArrayHandle]
-_linalg_gelqf args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_gelqf_upd ::
-                  forall args . Fullfilled "_linalg_gelqf(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_gelqf(ndarray)" args -> IO ()
-_linalg_gelqf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_gelqf(ndarray)" = '[]
-
-_backward_linalg_gelqf ::
-                       forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_gelqf(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_gelqf args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_gelqf_upd ::
-                           forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> IO ()
-_backward_linalg_gelqf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_syevd(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_syevd ::
-              forall args . Fullfilled "_linalg_syevd(ndarray)" args =>
-                ArgsHMap "_linalg_syevd(ndarray)" args -> IO [NDArrayHandle]
-_linalg_syevd args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_syevd_upd ::
-                  forall args . Fullfilled "_linalg_syevd(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_syevd(ndarray)" args -> IO ()
-_linalg_syevd_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_syevd(ndarray)" = '[]
-
-_backward_linalg_syevd ::
-                       forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_syevd(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_syevd args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_syevd_upd ::
-                           forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_syevd(ndarray)" args -> IO ()
-_backward_linalg_syevd_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_histogram(ndarray)" =
-     '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle), '("bins", AttrOpt NDArrayHandle)]
-
-_histogram ::
-           forall args . Fullfilled "_histogram(ndarray)" args =>
-             ArgsHMap "_histogram(ndarray)" args -> IO [NDArrayHandle]
-_histogram args
-  = let scalarArgs
-          = catMaybes
-              [("bin_cnt",) . showValue <$>
-                 (args !? #bin_cnt :: Maybe (Maybe Int)),
-               ("range",) . showValue <$> (args !? #range :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_histogram"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_histogram_upd ::
-               forall args . Fullfilled "_histogram(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_histogram(ndarray)" args -> IO ()
-_histogram_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("bin_cnt",) . showValue <$>
-                 (args !? #bin_cnt :: Maybe (Maybe Int)),
-               ("range",) . showValue <$> (args !? #range :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_histogram"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cast_storage(ndarray)" =
-     '[ '("stype",
-          AttrReq (EnumType '["csr", "default", "row_sparse"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-cast_storage ::
-             forall args . Fullfilled "cast_storage(ndarray)" args =>
-               ArgsHMap "cast_storage(ndarray)" args -> IO [NDArrayHandle]
-cast_storage args
-  = let scalarArgs
-          = catMaybes
-              [("stype",) . showValue <$>
-                 (args !? #stype ::
-                    Maybe (EnumType '["csr", "default", "row_sparse"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cast_storage"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cast_storage_upd ::
-                 forall args . Fullfilled "cast_storage(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "cast_storage(ndarray)" args -> IO ()
-cast_storage_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("stype",) . showValue <$>
-                 (args !? #stype ::
-                    Maybe (EnumType '["csr", "default", "row_sparse"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cast_storage"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_equal_scalar ::
-              forall args . Fullfilled "_equal_scalar(ndarray)" args =>
-                ArgsHMap "_equal_scalar(ndarray)" args -> IO [NDArrayHandle]
-_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_equal_scalar_upd ::
-                  forall args . Fullfilled "_equal_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_equal_scalar(ndarray)" args -> IO ()
-_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_not_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_not_equal_scalar ::
-                  forall args . Fullfilled "_not_equal_scalar(ndarray)" args =>
-                    ArgsHMap "_not_equal_scalar(ndarray)" args -> IO [NDArrayHandle]
-_not_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_not_equal_scalar_upd ::
-                      forall args . Fullfilled "_not_equal_scalar(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_not_equal_scalar(ndarray)" args -> IO ()
-_not_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_greater_scalar ::
-                forall args . Fullfilled "_greater_scalar(ndarray)" args =>
-                  ArgsHMap "_greater_scalar(ndarray)" args -> IO [NDArrayHandle]
-_greater_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_scalar_upd ::
-                    forall args . Fullfilled "_greater_scalar(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_greater_scalar(ndarray)" args -> IO ()
-_greater_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_greater_equal_scalar ::
-                      forall args . Fullfilled "_greater_equal_scalar(ndarray)" args =>
-                        ArgsHMap "_greater_equal_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_greater_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_equal_scalar_upd ::
-                          forall args . Fullfilled "_greater_equal_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_greater_equal_scalar(ndarray)" args -> IO ()
-_greater_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_lesser_scalar ::
-               forall args . Fullfilled "_lesser_scalar(ndarray)" args =>
-                 ArgsHMap "_lesser_scalar(ndarray)" args -> IO [NDArrayHandle]
-_lesser_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_scalar_upd ::
-                   forall args . Fullfilled "_lesser_scalar(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_lesser_scalar(ndarray)" args -> IO ()
-_lesser_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_lesser_equal_scalar ::
-                     forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args =>
-                       ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO [NDArrayHandle]
-_lesser_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_equal_scalar_upd ::
-                         forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO ()
-_lesser_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_and_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_logical_and_scalar ::
-                    forall args . Fullfilled "_logical_and_scalar(ndarray)" args =>
-                      ArgsHMap "_logical_and_scalar(ndarray)" args -> IO [NDArrayHandle]
-_logical_and_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_and_scalar_upd ::
-                        forall args . Fullfilled "_logical_and_scalar(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_logical_and_scalar(ndarray)" args -> IO ()
-_logical_and_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_or_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_logical_or_scalar ::
-                   forall args . Fullfilled "_logical_or_scalar(ndarray)" args =>
-                     ArgsHMap "_logical_or_scalar(ndarray)" args -> IO [NDArrayHandle]
-_logical_or_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_or_scalar_upd ::
-                       forall args . Fullfilled "_logical_or_scalar(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_logical_or_scalar(ndarray)" args -> IO ()
-_logical_or_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_xor_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_logical_xor_scalar ::
-                    forall args . Fullfilled "_logical_xor_scalar(ndarray)" args =>
-                      ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO [NDArrayHandle]
-_logical_xor_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_xor_scalar_upd ::
-                        forall args . Fullfilled "_logical_xor_scalar(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO ()
-_logical_xor_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "relu(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-relu ::
-     forall args . Fullfilled "relu(ndarray)" args =>
-       ArgsHMap "relu(ndarray)" args -> IO [NDArrayHandle]
-relu args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-relu_upd ::
-         forall args . Fullfilled "relu(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "relu(ndarray)" args -> IO ()
-relu_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_relu(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_relu ::
-               forall args . Fullfilled "_backward_relu(ndarray)" args =>
-                 ArgsHMap "_backward_relu(ndarray)" args -> IO [NDArrayHandle]
-_backward_relu args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_relu_upd ::
-                   forall args . Fullfilled "_backward_relu(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_relu(ndarray)" args -> IO ()
-_backward_relu_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sigmoid(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sigmoid ::
-        forall args . Fullfilled "sigmoid(ndarray)" args =>
-          ArgsHMap "sigmoid(ndarray)" args -> IO [NDArrayHandle]
-sigmoid args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sigmoid_upd ::
-            forall args . Fullfilled "sigmoid(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "sigmoid(ndarray)" args -> IO ()
-sigmoid_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sigmoid(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sigmoid ::
-                  forall args . Fullfilled "_backward_sigmoid(ndarray)" args =>
-                    ArgsHMap "_backward_sigmoid(ndarray)" args -> IO [NDArrayHandle]
-_backward_sigmoid args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sigmoid_upd ::
-                      forall args . Fullfilled "_backward_sigmoid(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_sigmoid(ndarray)" args -> IO ()
-_backward_sigmoid_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "hard_sigmoid(ndarray)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-hard_sigmoid ::
-             forall args . Fullfilled "hard_sigmoid(ndarray)" args =>
-               ArgsHMap "hard_sigmoid(ndarray)" args -> IO [NDArrayHandle]
-hard_sigmoid args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "hard_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-hard_sigmoid_upd ::
-                 forall args . Fullfilled "hard_sigmoid(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "hard_sigmoid(ndarray)" args -> IO ()
-hard_sigmoid_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "hard_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_hard_sigmoid(ndarray)" = '[]
-
-_backward_hard_sigmoid ::
-                       forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args =>
-                         ArgsHMap "_backward_hard_sigmoid(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_hard_sigmoid args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hard_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_hard_sigmoid_upd ::
-                           forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_hard_sigmoid(ndarray)" args -> IO ()
-_backward_hard_sigmoid_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hard_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "softsign(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-softsign ::
-         forall args . Fullfilled "softsign(ndarray)" args =>
-           ArgsHMap "softsign(ndarray)" args -> IO [NDArrayHandle]
-softsign args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softsign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-softsign_upd ::
-             forall args . Fullfilled "softsign(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "softsign(ndarray)" args -> IO ()
-softsign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softsign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_softsign(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_softsign ::
-                   forall args . Fullfilled "_backward_softsign(ndarray)" args =>
-                     ArgsHMap "_backward_softsign(ndarray)" args -> IO [NDArrayHandle]
-_backward_softsign args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softsign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_softsign_upd ::
-                       forall args . Fullfilled "_backward_softsign(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_softsign(ndarray)" args -> IO ()
-_backward_softsign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softsign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_copy(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_copy ::
-      forall args . Fullfilled "_copy(ndarray)" args =>
-        ArgsHMap "_copy(ndarray)" args -> IO [NDArrayHandle]
-_copy args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_copy_upd ::
-          forall args . Fullfilled "_copy(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_copy(ndarray)" args -> IO ()
-_copy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_copy(ndarray)" = '[]
-
-_backward_copy ::
-               forall args . Fullfilled "_backward_copy(ndarray)" args =>
-                 ArgsHMap "_backward_copy(ndarray)" args -> IO [NDArrayHandle]
-_backward_copy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_copy_upd ::
-                   forall args . Fullfilled "_backward_copy(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_copy(ndarray)" args -> IO ()
-_backward_copy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BlockGrad(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_BlockGrad ::
-           forall args . Fullfilled "_BlockGrad(ndarray)" args =>
-             ArgsHMap "_BlockGrad(ndarray)" args -> IO [NDArrayHandle]
-_BlockGrad args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BlockGrad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BlockGrad_upd ::
-               forall args . Fullfilled "_BlockGrad(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_BlockGrad(ndarray)" args -> IO ()
-_BlockGrad_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BlockGrad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "make_loss(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-make_loss ::
-          forall args . Fullfilled "make_loss(ndarray)" args =>
-            ArgsHMap "make_loss(ndarray)" args -> IO [NDArrayHandle]
-make_loss args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "make_loss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-make_loss_upd ::
-              forall args . Fullfilled "make_loss(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "make_loss(ndarray)" args -> IO ()
-make_loss_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "make_loss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_identity_with_attr_like_rhs(ndarray)"
-     =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_identity_with_attr_like_rhs ::
-                             forall args .
-                               Fullfilled "_identity_with_attr_like_rhs(ndarray)" args =>
-                               ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_identity_with_attr_like_rhs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_identity_with_attr_like_rhs_upd ::
-                                 forall args .
-                                   Fullfilled "_identity_with_attr_like_rhs(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> IO ()
-_identity_with_attr_like_rhs_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "reshape_like(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-reshape_like ::
-             forall args . Fullfilled "reshape_like(ndarray)" args =>
-               ArgsHMap "reshape_like(ndarray)" args -> IO [NDArrayHandle]
-reshape_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reshape_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-reshape_like_upd ::
-                 forall args . Fullfilled "reshape_like(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "reshape_like(ndarray)" args -> IO ()
-reshape_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reshape_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "shape_array(ndarray)" =
-     '[ '("lhs_begin", AttrOpt (Maybe Int)),
-        '("lhs_end", AttrOpt (Maybe Int)),
-        '("rhs_begin", AttrOpt (Maybe Int)),
-        '("rhs_end", AttrOpt (Maybe Int)),
-        '("data", AttrOpt NDArrayHandle)]
-
-shape_array ::
-            forall args . Fullfilled "shape_array(ndarray)" args =>
-              ArgsHMap "shape_array(ndarray)" args -> IO [NDArrayHandle]
-shape_array args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_begin",) . showValue <$>
-                 (args !? #lhs_begin :: Maybe (Maybe Int)),
-               ("lhs_end",) . showValue <$>
-                 (args !? #lhs_end :: Maybe (Maybe Int)),
-               ("rhs_begin",) . showValue <$>
-                 (args !? #rhs_begin :: Maybe (Maybe Int)),
-               ("rhs_end",) . showValue <$>
-                 (args !? #rhs_end :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "shape_array"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-shape_array_upd ::
-                forall args . Fullfilled "shape_array(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "shape_array(ndarray)" args -> IO ()
-shape_array_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_begin",) . showValue <$>
-                 (args !? #lhs_begin :: Maybe (Maybe Int)),
-               ("lhs_end",) . showValue <$>
-                 (args !? #lhs_end :: Maybe (Maybe Int)),
-               ("rhs_begin",) . showValue <$>
-                 (args !? #rhs_begin :: Maybe (Maybe Int)),
-               ("rhs_end",) . showValue <$>
-                 (args !? #rhs_end :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "shape_array"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "size_array(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-size_array ::
-           forall args . Fullfilled "size_array(ndarray)" args =>
-             ArgsHMap "size_array(ndarray)" args -> IO [NDArrayHandle]
-size_array args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "size_array"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-size_array_upd ::
-               forall args . Fullfilled "size_array(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "size_array(ndarray)" args -> IO ()
-size_array_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "size_array"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Cast(ndarray)" =
-     '[ '("dtype",
-          AttrReq
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Cast ::
-      forall args . Fullfilled "_Cast(ndarray)" args =>
-        ArgsHMap "_Cast(ndarray)" args -> IO [NDArrayHandle]
-_Cast args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Cast_upd ::
-          forall args . Fullfilled "_Cast(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_Cast(ndarray)" args -> IO ()
-_Cast_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cast(ndarray)" = '[]
-
-_backward_cast ::
-               forall args . Fullfilled "_backward_cast(ndarray)" args =>
-                 ArgsHMap "_backward_cast(ndarray)" args -> IO [NDArrayHandle]
-_backward_cast args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cast_upd ::
-                   forall args . Fullfilled "_backward_cast(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cast(ndarray)" args -> IO ()
-_backward_cast_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "negative(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-negative ::
-         forall args . Fullfilled "negative(ndarray)" args =>
-           ArgsHMap "negative(ndarray)" args -> IO [NDArrayHandle]
-negative args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "negative"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-negative_upd ::
-             forall args . Fullfilled "negative(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "negative(ndarray)" args -> IO ()
-negative_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "negative"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "reciprocal(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-reciprocal ::
-           forall args . Fullfilled "reciprocal(ndarray)" args =>
-             ArgsHMap "reciprocal(ndarray)" args -> IO [NDArrayHandle]
-reciprocal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-reciprocal_upd ::
-               forall args . Fullfilled "reciprocal(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "reciprocal(ndarray)" args -> IO ()
-reciprocal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_reciprocal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_reciprocal ::
-                     forall args . Fullfilled "_backward_reciprocal(ndarray)" args =>
-                       ArgsHMap "_backward_reciprocal(ndarray)" args -> IO [NDArrayHandle]
-_backward_reciprocal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_reciprocal_upd ::
-                         forall args . Fullfilled "_backward_reciprocal(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_reciprocal(ndarray)" args -> IO ()
-_backward_reciprocal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "abs(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-abs ::
-    forall args . Fullfilled "abs(ndarray)" args =>
-      ArgsHMap "abs(ndarray)" args -> IO [NDArrayHandle]
-abs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-abs_upd ::
-        forall args . Fullfilled "abs(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "abs(ndarray)" args -> IO ()
-abs_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_abs(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_abs ::
-              forall args . Fullfilled "_backward_abs(ndarray)" args =>
-                ArgsHMap "_backward_abs(ndarray)" args -> IO [NDArrayHandle]
-_backward_abs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_abs_upd ::
-                  forall args . Fullfilled "_backward_abs(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_abs(ndarray)" args -> IO ()
-_backward_abs_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sign(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sign ::
-     forall args . Fullfilled "sign(ndarray)" args =>
-       ArgsHMap "sign(ndarray)" args -> IO [NDArrayHandle]
-sign args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sign_upd ::
-         forall args . Fullfilled "sign(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sign(ndarray)" args -> IO ()
-sign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sign(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sign ::
-               forall args . Fullfilled "_backward_sign(ndarray)" args =>
-                 ArgsHMap "_backward_sign(ndarray)" args -> IO [NDArrayHandle]
-_backward_sign args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sign_upd ::
-                   forall args . Fullfilled "_backward_sign(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_sign(ndarray)" args -> IO ()
-_backward_sign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "round(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-round ::
-      forall args . Fullfilled "round(ndarray)" args =>
-        ArgsHMap "round(ndarray)" args -> IO [NDArrayHandle]
-round args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "round"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-round_upd ::
-          forall args . Fullfilled "round(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "round(ndarray)" args -> IO ()
-round_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "round"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rint(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-rint ::
-     forall args . Fullfilled "rint(ndarray)" args =>
-       ArgsHMap "rint(ndarray)" args -> IO [NDArrayHandle]
-rint args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rint"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rint_upd ::
-         forall args . Fullfilled "rint(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "rint(ndarray)" args -> IO ()
-rint_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rint"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ceil(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-ceil ::
-     forall args . Fullfilled "ceil(ndarray)" args =>
-       ArgsHMap "ceil(ndarray)" args -> IO [NDArrayHandle]
-ceil args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ceil"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ceil_upd ::
-         forall args . Fullfilled "ceil(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "ceil(ndarray)" args -> IO ()
-ceil_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ceil"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "floor(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-floor ::
-      forall args . Fullfilled "floor(ndarray)" args =>
-        ArgsHMap "floor(ndarray)" args -> IO [NDArrayHandle]
-floor args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "floor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-floor_upd ::
-          forall args . Fullfilled "floor(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "floor(ndarray)" args -> IO ()
-floor_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "floor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "trunc(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-trunc ::
-      forall args . Fullfilled "trunc(ndarray)" args =>
-        ArgsHMap "trunc(ndarray)" args -> IO [NDArrayHandle]
-trunc args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "trunc"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-trunc_upd ::
-          forall args . Fullfilled "trunc(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "trunc(ndarray)" args -> IO ()
-trunc_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "trunc"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "fix(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-fix ::
-    forall args . Fullfilled "fix(ndarray)" args =>
-      ArgsHMap "fix(ndarray)" args -> IO [NDArrayHandle]
-fix args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fix"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-fix_upd ::
-        forall args . Fullfilled "fix(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "fix(ndarray)" args -> IO ()
-fix_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fix"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "square(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-square ::
-       forall args . Fullfilled "square(ndarray)" args =>
-         ArgsHMap "square(ndarray)" args -> IO [NDArrayHandle]
-square args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-square_upd ::
-           forall args . Fullfilled "square(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "square(ndarray)" args -> IO ()
-square_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_square(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_square ::
-                 forall args . Fullfilled "_backward_square(ndarray)" args =>
-                   ArgsHMap "_backward_square(ndarray)" args -> IO [NDArrayHandle]
-_backward_square args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_square_upd ::
-                     forall args . Fullfilled "_backward_square(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_square(ndarray)" args -> IO ()
-_backward_square_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sqrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sqrt ::
-     forall args . Fullfilled "sqrt(ndarray)" args =>
-       ArgsHMap "sqrt(ndarray)" args -> IO [NDArrayHandle]
-sqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sqrt_upd ::
-         forall args . Fullfilled "sqrt(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sqrt(ndarray)" args -> IO ()
-sqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sqrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sqrt ::
-               forall args . Fullfilled "_backward_sqrt(ndarray)" args =>
-                 ArgsHMap "_backward_sqrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_sqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sqrt_upd ::
-                   forall args . Fullfilled "_backward_sqrt(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_sqrt(ndarray)" args -> IO ()
-_backward_sqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rsqrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-rsqrt ::
-      forall args . Fullfilled "rsqrt(ndarray)" args =>
-        ArgsHMap "rsqrt(ndarray)" args -> IO [NDArrayHandle]
-rsqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rsqrt_upd ::
-          forall args . Fullfilled "rsqrt(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "rsqrt(ndarray)" args -> IO ()
-rsqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rsqrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rsqrt ::
-                forall args . Fullfilled "_backward_rsqrt(ndarray)" args =>
-                  ArgsHMap "_backward_rsqrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_rsqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rsqrt_upd ::
-                    forall args . Fullfilled "_backward_rsqrt(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_rsqrt(ndarray)" args -> IO ()
-_backward_rsqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cbrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-cbrt ::
-     forall args . Fullfilled "cbrt(ndarray)" args =>
-       ArgsHMap "cbrt(ndarray)" args -> IO [NDArrayHandle]
-cbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cbrt_upd ::
-         forall args . Fullfilled "cbrt(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "cbrt(ndarray)" args -> IO ()
-cbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cbrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_cbrt ::
-               forall args . Fullfilled "_backward_cbrt(ndarray)" args =>
-                 ArgsHMap "_backward_cbrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_cbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cbrt_upd ::
-                   forall args . Fullfilled "_backward_cbrt(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cbrt(ndarray)" args -> IO ()
-_backward_cbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rcbrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-rcbrt ::
-      forall args . Fullfilled "rcbrt(ndarray)" args =>
-        ArgsHMap "rcbrt(ndarray)" args -> IO [NDArrayHandle]
-rcbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rcbrt_upd ::
-          forall args . Fullfilled "rcbrt(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "rcbrt(ndarray)" args -> IO ()
-rcbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rcbrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rcbrt ::
-                forall args . Fullfilled "_backward_rcbrt(ndarray)" args =>
-                  ArgsHMap "_backward_rcbrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_rcbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rcbrt_upd ::
-                    forall args . Fullfilled "_backward_rcbrt(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_rcbrt(ndarray)" args -> IO ()
-_backward_rcbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "exp(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-exp ::
-    forall args . Fullfilled "exp(ndarray)" args =>
-      ArgsHMap "exp(ndarray)" args -> IO [NDArrayHandle]
-exp args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "exp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-exp_upd ::
-        forall args . Fullfilled "exp(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "exp(ndarray)" args -> IO ()
-exp_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "exp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log ::
-    forall args . Fullfilled "log(ndarray)" args =>
-      ArgsHMap "log(ndarray)" args -> IO [NDArrayHandle]
-log args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log_upd ::
-        forall args . Fullfilled "log(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "log(ndarray)" args -> IO ()
-log_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log10(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log10 ::
-      forall args . Fullfilled "log10(ndarray)" args =>
-        ArgsHMap "log10(ndarray)" args -> IO [NDArrayHandle]
-log10 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log10_upd ::
-          forall args . Fullfilled "log10(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "log10(ndarray)" args -> IO ()
-log10_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log2(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log2 ::
-     forall args . Fullfilled "log2(ndarray)" args =>
-       ArgsHMap "log2(ndarray)" args -> IO [NDArrayHandle]
-log2 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log2_upd ::
-         forall args . Fullfilled "log2(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "log2(ndarray)" args -> IO ()
-log2_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log ::
-              forall args . Fullfilled "_backward_log(ndarray)" args =>
-                ArgsHMap "_backward_log(ndarray)" args -> IO [NDArrayHandle]
-_backward_log args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log_upd ::
-                  forall args . Fullfilled "_backward_log(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_log(ndarray)" args -> IO ()
-_backward_log_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log10(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log10 ::
-                forall args . Fullfilled "_backward_log10(ndarray)" args =>
-                  ArgsHMap "_backward_log10(ndarray)" args -> IO [NDArrayHandle]
-_backward_log10 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log10_upd ::
-                    forall args . Fullfilled "_backward_log10(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_log10(ndarray)" args -> IO ()
-_backward_log10_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log2(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log2 ::
-               forall args . Fullfilled "_backward_log2(ndarray)" args =>
-                 ArgsHMap "_backward_log2(ndarray)" args -> IO [NDArrayHandle]
-_backward_log2 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log2_upd ::
-                   forall args . Fullfilled "_backward_log2(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_log2(ndarray)" args -> IO ()
-_backward_log2_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log1p(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log1p ::
-      forall args . Fullfilled "log1p(ndarray)" args =>
-        ArgsHMap "log1p(ndarray)" args -> IO [NDArrayHandle]
-log1p args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log1p_upd ::
-          forall args . Fullfilled "log1p(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "log1p(ndarray)" args -> IO ()
-log1p_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log1p(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log1p ::
-                forall args . Fullfilled "_backward_log1p(ndarray)" args =>
-                  ArgsHMap "_backward_log1p(ndarray)" args -> IO [NDArrayHandle]
-_backward_log1p args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log1p_upd ::
-                    forall args . Fullfilled "_backward_log1p(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_log1p(ndarray)" args -> IO ()
-_backward_log1p_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "expm1(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-expm1 ::
-      forall args . Fullfilled "expm1(ndarray)" args =>
-        ArgsHMap "expm1(ndarray)" args -> IO [NDArrayHandle]
-expm1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-expm1_upd ::
-          forall args . Fullfilled "expm1(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "expm1(ndarray)" args -> IO ()
-expm1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_expm1(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_expm1 ::
-                forall args . Fullfilled "_backward_expm1(ndarray)" args =>
-                  ArgsHMap "_backward_expm1(ndarray)" args -> IO [NDArrayHandle]
-_backward_expm1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_expm1_upd ::
-                    forall args . Fullfilled "_backward_expm1(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_expm1(ndarray)" args -> IO ()
-_backward_expm1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "gamma(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-gamma ::
-      forall args . Fullfilled "gamma(ndarray)" args =>
-        ArgsHMap "gamma(ndarray)" args -> IO [NDArrayHandle]
-gamma args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-gamma_upd ::
-          forall args . Fullfilled "gamma(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "gamma(ndarray)" args -> IO ()
-gamma_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_gamma(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_gamma ::
-                forall args . Fullfilled "_backward_gamma(ndarray)" args =>
-                  ArgsHMap "_backward_gamma(ndarray)" args -> IO [NDArrayHandle]
-_backward_gamma args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_gamma_upd ::
-                    forall args . Fullfilled "_backward_gamma(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_gamma(ndarray)" args -> IO ()
-_backward_gamma_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "gammaln(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-gammaln ::
-        forall args . Fullfilled "gammaln(ndarray)" args =>
-          ArgsHMap "gammaln(ndarray)" args -> IO [NDArrayHandle]
-gammaln args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-gammaln_upd ::
-            forall args . Fullfilled "gammaln(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "gammaln(ndarray)" args -> IO ()
-gammaln_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_gammaln(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_gammaln ::
-                  forall args . Fullfilled "_backward_gammaln(ndarray)" args =>
-                    ArgsHMap "_backward_gammaln(ndarray)" args -> IO [NDArrayHandle]
-_backward_gammaln args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_gammaln_upd ::
-                      forall args . Fullfilled "_backward_gammaln(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_gammaln(ndarray)" args -> IO ()
-_backward_gammaln_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "logical_not(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-logical_not ::
-            forall args . Fullfilled "logical_not(ndarray)" args =>
-              ArgsHMap "logical_not(ndarray)" args -> IO [NDArrayHandle]
-logical_not args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "logical_not"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-logical_not_upd ::
-                forall args . Fullfilled "logical_not(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "logical_not(ndarray)" args -> IO ()
-logical_not_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "logical_not"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sum(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-sum ::
-    forall args . Fullfilled "sum(ndarray)" args =>
-      ArgsHMap "sum(ndarray)" args -> IO [NDArrayHandle]
-sum args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sum_upd ::
-        forall args . Fullfilled "sum(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "sum(ndarray)" args -> IO ()
-sum_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sum(ndarray)" = '[]
-
-_backward_sum ::
-              forall args . Fullfilled "_backward_sum(ndarray)" args =>
-                ArgsHMap "_backward_sum(ndarray)" args -> IO [NDArrayHandle]
-_backward_sum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sum_upd ::
-                  forall args . Fullfilled "_backward_sum(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_sum(ndarray)" args -> IO ()
-_backward_sum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "mean(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-mean ::
-     forall args . Fullfilled "mean(ndarray)" args =>
-       ArgsHMap "mean(ndarray)" args -> IO [NDArrayHandle]
-mean args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-mean_upd ::
-         forall args . Fullfilled "mean(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "mean(ndarray)" args -> IO ()
-mean_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mean(ndarray)" = '[]
-
-_backward_mean ::
-               forall args . Fullfilled "_backward_mean(ndarray)" args =>
-                 ArgsHMap "_backward_mean(ndarray)" args -> IO [NDArrayHandle]
-_backward_mean args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mean_upd ::
-                   forall args . Fullfilled "_backward_mean(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_mean(ndarray)" args -> IO ()
-_backward_mean_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "prod(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-prod ::
-     forall args . Fullfilled "prod(ndarray)" args =>
-       ArgsHMap "prod(ndarray)" args -> IO [NDArrayHandle]
-prod args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-prod_upd ::
-         forall args . Fullfilled "prod(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "prod(ndarray)" args -> IO ()
-prod_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_prod(ndarray)" = '[]
-
-_backward_prod ::
-               forall args . Fullfilled "_backward_prod(ndarray)" args =>
-                 ArgsHMap "_backward_prod(ndarray)" args -> IO [NDArrayHandle]
-_backward_prod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_prod_upd ::
-                   forall args . Fullfilled "_backward_prod(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_prod(ndarray)" args -> IO ()
-_backward_prod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "nansum(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-nansum ::
-       forall args . Fullfilled "nansum(ndarray)" args =>
-         ArgsHMap "nansum(ndarray)" args -> IO [NDArrayHandle]
-nansum args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-nansum_upd ::
-           forall args . Fullfilled "nansum(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "nansum(ndarray)" args -> IO ()
-nansum_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_nansum(ndarray)" = '[]
-
-_backward_nansum ::
-                 forall args . Fullfilled "_backward_nansum(ndarray)" args =>
-                   ArgsHMap "_backward_nansum(ndarray)" args -> IO [NDArrayHandle]
-_backward_nansum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_nansum_upd ::
-                     forall args . Fullfilled "_backward_nansum(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_nansum(ndarray)" args -> IO ()
-_backward_nansum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "nanprod(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-nanprod ::
-        forall args . Fullfilled "nanprod(ndarray)" args =>
-          ArgsHMap "nanprod(ndarray)" args -> IO [NDArrayHandle]
-nanprod args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-nanprod_upd ::
-            forall args . Fullfilled "nanprod(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "nanprod(ndarray)" args -> IO ()
-nanprod_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_nanprod(ndarray)" = '[]
-
-_backward_nanprod ::
-                  forall args . Fullfilled "_backward_nanprod(ndarray)" args =>
-                    ArgsHMap "_backward_nanprod(ndarray)" args -> IO [NDArrayHandle]
-_backward_nanprod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_nanprod_upd ::
-                      forall args . Fullfilled "_backward_nanprod(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_nanprod(ndarray)" args -> IO ()
-_backward_nanprod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "max(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-max ::
-    forall args . Fullfilled "max(ndarray)" args =>
-      ArgsHMap "max(ndarray)" args -> IO [NDArrayHandle]
-max args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-max_upd ::
-        forall args . Fullfilled "max(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "max(ndarray)" args -> IO ()
-max_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_max(ndarray)" = '[]
-
-_backward_max ::
-              forall args . Fullfilled "_backward_max(ndarray)" args =>
-                ArgsHMap "_backward_max(ndarray)" args -> IO [NDArrayHandle]
-_backward_max args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_max_upd ::
-                  forall args . Fullfilled "_backward_max(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_max(ndarray)" args -> IO ()
-_backward_max_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "min(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-min ::
-    forall args . Fullfilled "min(ndarray)" args =>
-      ArgsHMap "min(ndarray)" args -> IO [NDArrayHandle]
-min args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-min_upd ::
-        forall args . Fullfilled "min(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "min(ndarray)" args -> IO ()
-min_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_min(ndarray)" = '[]
-
-_backward_min ::
-              forall args . Fullfilled "_backward_min(ndarray)" args =>
-                ArgsHMap "_backward_min(ndarray)" args -> IO [NDArrayHandle]
-_backward_min args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_min_upd ::
-                  forall args . Fullfilled "_backward_min(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_min(ndarray)" args -> IO ()
-_backward_min_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_axis(ndarray)" =
-     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-broadcast_axis ::
-               forall args . Fullfilled "broadcast_axis(ndarray)" args =>
-                 ArgsHMap "broadcast_axis(ndarray)" args -> IO [NDArrayHandle]
-broadcast_axis args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_axis_upd ::
-                   forall args . Fullfilled "broadcast_axis(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "broadcast_axis(ndarray)" args -> IO ()
-broadcast_axis_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_to(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-broadcast_to ::
-             forall args . Fullfilled "broadcast_to(ndarray)" args =>
-               ArgsHMap "broadcast_to(ndarray)" args -> IO [NDArrayHandle]
-broadcast_to args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_to"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_to_upd ::
-                 forall args . Fullfilled "broadcast_to(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "broadcast_to(ndarray)" args -> IO ()
-broadcast_to_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_to"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_broadcast_backward(ndarray)" = '[]
-
-_broadcast_backward ::
-                    forall args . Fullfilled "_broadcast_backward(ndarray)" args =>
-                      ArgsHMap "_broadcast_backward(ndarray)" args -> IO [NDArrayHandle]
-_broadcast_backward args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_broadcast_backward"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_broadcast_backward_upd ::
-                        forall args . Fullfilled "_broadcast_backward(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_broadcast_backward(ndarray)" args -> IO ()
-_broadcast_backward_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_broadcast_backward"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_like(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_like ::
-               forall args . Fullfilled "broadcast_like(ndarray)" args =>
-                 ArgsHMap "broadcast_like(ndarray)" args -> IO [NDArrayHandle]
-broadcast_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_like_upd ::
-                   forall args . Fullfilled "broadcast_like(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "broadcast_like(ndarray)" args -> IO ()
-broadcast_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "norm(ndarray)" =
-     '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])),
-        '("keepdims", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-norm ::
-     forall args . Fullfilled "norm(ndarray)" args =>
-       ArgsHMap "norm(ndarray)" args -> IO [NDArrayHandle]
-norm args
-  = let scalarArgs
-          = catMaybes
-              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "norm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-norm_upd ::
-         forall args . Fullfilled "norm(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "norm(ndarray)" args -> IO ()
-norm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "norm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_norm(ndarray)" = '[]
-
-_backward_norm ::
-               forall args . Fullfilled "_backward_norm(ndarray)" args =>
-                 ArgsHMap "_backward_norm(ndarray)" args -> IO [NDArrayHandle]
-_backward_norm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_norm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_norm_upd ::
-                   forall args . Fullfilled "_backward_norm(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_norm(ndarray)" args -> IO ()
-_backward_norm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_norm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_add(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_add ::
-             forall args . Fullfilled "elemwise_add(ndarray)" args =>
-               ArgsHMap "elemwise_add(ndarray)" args -> IO [NDArrayHandle]
-elemwise_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_add_upd ::
-                 forall args . Fullfilled "elemwise_add(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_add(ndarray)" args -> IO ()
-elemwise_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_grad_add(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_grad_add ::
-          forall args . Fullfilled "_grad_add(ndarray)" args =>
-            ArgsHMap "_grad_add(ndarray)" args -> IO [NDArrayHandle]
-_grad_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_grad_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_grad_add_upd ::
-              forall args . Fullfilled "_grad_add(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_grad_add(ndarray)" args -> IO ()
-_grad_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_grad_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_add(ndarray)" = '[]
-
-_backward_add ::
-              forall args . Fullfilled "_backward_add(ndarray)" args =>
-                ArgsHMap "_backward_add(ndarray)" args -> IO [NDArrayHandle]
-_backward_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_add_upd ::
-                  forall args . Fullfilled "_backward_add(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_add(ndarray)" args -> IO ()
-_backward_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_sub(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_sub ::
-             forall args . Fullfilled "elemwise_sub(ndarray)" args =>
-               ArgsHMap "elemwise_sub(ndarray)" args -> IO [NDArrayHandle]
-elemwise_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_sub_upd ::
-                 forall args . Fullfilled "elemwise_sub(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_sub(ndarray)" args -> IO ()
-elemwise_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sub(ndarray)" = '[]
-
-_backward_sub ::
-              forall args . Fullfilled "_backward_sub(ndarray)" args =>
-                ArgsHMap "_backward_sub(ndarray)" args -> IO [NDArrayHandle]
-_backward_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sub_upd ::
-                  forall args . Fullfilled "_backward_sub(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_sub(ndarray)" args -> IO ()
-_backward_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_mul(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_mul ::
-             forall args . Fullfilled "elemwise_mul(ndarray)" args =>
-               ArgsHMap "elemwise_mul(ndarray)" args -> IO [NDArrayHandle]
-elemwise_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_mul_upd ::
-                 forall args . Fullfilled "elemwise_mul(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_mul(ndarray)" args -> IO ()
-elemwise_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mul(ndarray)" = '[]
-
-_backward_mul ::
-              forall args . Fullfilled "_backward_mul(ndarray)" args =>
-                ArgsHMap "_backward_mul(ndarray)" args -> IO [NDArrayHandle]
-_backward_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mul_upd ::
-                  forall args . Fullfilled "_backward_mul(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_mul(ndarray)" args -> IO ()
-_backward_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_div(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_div ::
-             forall args . Fullfilled "elemwise_div(ndarray)" args =>
-               ArgsHMap "elemwise_div(ndarray)" args -> IO [NDArrayHandle]
-elemwise_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_div_upd ::
-                 forall args . Fullfilled "elemwise_div(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_div(ndarray)" args -> IO ()
-elemwise_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_div(ndarray)" = '[]
-
-_backward_div ::
-              forall args . Fullfilled "_backward_div(ndarray)" args =>
-                ArgsHMap "_backward_div(ndarray)" args -> IO [NDArrayHandle]
-_backward_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_div_upd ::
-                  forall args . Fullfilled "_backward_div(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_div(ndarray)" args -> IO ()
-_backward_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_mod(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_mod ::
-     forall args . Fullfilled "_mod(ndarray)" args =>
-       ArgsHMap "_mod(ndarray)" args -> IO [NDArrayHandle]
-_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_mod_upd ::
-         forall args . Fullfilled "_mod(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_mod(ndarray)" args -> IO ()
-_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mod(ndarray)" = '[]
-
-_backward_mod ::
-              forall args . Fullfilled "_backward_mod(ndarray)" args =>
-                ArgsHMap "_backward_mod(ndarray)" args -> IO [NDArrayHandle]
-_backward_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mod_upd ::
-                  forall args . Fullfilled "_backward_mod(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_mod(ndarray)" args -> IO ()
-_backward_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_elemwise_div(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_scatter_elemwise_div ::
-                      forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args =>
-                        ArgsHMap "_scatter_elemwise_div(ndarray)" args ->
-                          IO [NDArrayHandle]
-_scatter_elemwise_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_elemwise_div_upd ::
-                          forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_scatter_elemwise_div(ndarray)" args -> IO ()
-_scatter_elemwise_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_plus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_scatter_plus_scalar ::
-                     forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args =>
-                       ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_scatter_plus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_plus_scalar_upd ::
-                         forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO ()
-_scatter_plus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_minus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_scatter_minus_scalar ::
-                      forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args =>
-                        ArgsHMap "_scatter_minus_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_scatter_minus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_minus_scalar_upd ::
-                          forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_scatter_minus_scalar(ndarray)" args -> IO ()
-_scatter_minus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Embedding(ndarray)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle)]
-
-_Embedding ::
-           forall args . Fullfilled "_Embedding(ndarray)" args =>
-             ArgsHMap "_Embedding(ndarray)" args -> IO [NDArrayHandle]
-_Embedding args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Embedding_upd ::
-               forall args . Fullfilled "_Embedding(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_Embedding(ndarray)" args -> IO ()
-_Embedding_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_SparseEmbedding(ndarray)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle)]
-
-_contrib_SparseEmbedding ::
-                         forall args .
-                           Fullfilled "_contrib_SparseEmbedding(ndarray)" args =>
-                           ArgsHMap "_contrib_SparseEmbedding(ndarray)" args ->
-                             IO [NDArrayHandle]
-_contrib_SparseEmbedding args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_SparseEmbedding_upd ::
-                             forall args .
-                               Fullfilled "_contrib_SparseEmbedding(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> IO ()
-_contrib_SparseEmbedding_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Embedding(ndarray)" = '[]
-
-_backward_Embedding ::
-                    forall args . Fullfilled "_backward_Embedding(ndarray)" args =>
-                      ArgsHMap "_backward_Embedding(ndarray)" args -> IO [NDArrayHandle]
-_backward_Embedding args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Embedding_upd ::
-                        forall args . Fullfilled "_backward_Embedding(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_Embedding(ndarray)" args -> IO ()
-_backward_Embedding_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SparseEmbedding(ndarray)" =
-     '[]
-
-_backward_SparseEmbedding ::
-                          forall args .
-                            Fullfilled "_backward_SparseEmbedding(ndarray)" args =>
-                            ArgsHMap "_backward_SparseEmbedding(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_SparseEmbedding args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SparseEmbedding_upd ::
-                              forall args .
-                                Fullfilled "_backward_SparseEmbedding(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> IO ()
-_backward_SparseEmbedding_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "take(ndarray)" =
-     '[ '("axis", AttrOpt Int),
-        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),
-        '("a", AttrOpt NDArrayHandle), '("indices", AttrOpt NDArrayHandle)]
-
-take ::
-     forall args . Fullfilled "take(ndarray)" args =>
-       ArgsHMap "take(ndarray)" args -> IO [NDArrayHandle]
-take args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-take_upd ::
-         forall args . Fullfilled "take(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "take(ndarray)" args -> IO ()
-take_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_take(ndarray)" = '[]
-
-_backward_take ::
-               forall args . Fullfilled "_backward_take(ndarray)" args =>
-                 ArgsHMap "_backward_take(ndarray)" args -> IO [NDArrayHandle]
-_backward_take args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_take_upd ::
-                   forall args . Fullfilled "_backward_take(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_take(ndarray)" args -> IO ()
-_backward_take_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "batch_take(ndarray)" =
-     '[ '("a", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-batch_take ::
-           forall args . Fullfilled "batch_take(ndarray)" args =>
-             ArgsHMap "batch_take(ndarray)" args -> IO [NDArrayHandle]
-batch_take args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-batch_take_upd ::
-               forall args . Fullfilled "batch_take(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "batch_take(ndarray)" args -> IO ()
-batch_take_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "one_hot(ndarray)" =
-     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),
-        '("off_value", AttrOpt Double),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("indices", AttrOpt NDArrayHandle)]
-
-one_hot ::
-        forall args . Fullfilled "one_hot(ndarray)" args =>
-          ArgsHMap "one_hot(ndarray)" args -> IO [NDArrayHandle]
-one_hot args
-  = let scalarArgs
-          = catMaybes
-              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),
-               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),
-               ("off_value",) . showValue <$>
-                 (args !? #off_value :: Maybe Double),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "one_hot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-one_hot_upd ::
-            forall args . Fullfilled "one_hot(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "one_hot(ndarray)" args -> IO ()
-one_hot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),
-               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),
-               ("off_value",) . showValue <$>
-                 (args !? #off_value :: Maybe Double),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "one_hot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "gather_nd(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-gather_nd ::
-          forall args . Fullfilled "gather_nd(ndarray)" args =>
-            ArgsHMap "gather_nd(ndarray)" args -> IO [NDArrayHandle]
-gather_nd args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gather_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-gather_nd_upd ::
-              forall args . Fullfilled "gather_nd(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "gather_nd(ndarray)" args -> IO ()
-gather_nd_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gather_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "scatter_nd(ndarray)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-scatter_nd ::
-           forall args . Fullfilled "scatter_nd(ndarray)" args =>
-             ArgsHMap "scatter_nd(ndarray)" args -> IO [NDArrayHandle]
-scatter_nd args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "scatter_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-scatter_nd_upd ::
-               forall args . Fullfilled "scatter_nd(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "scatter_nd(ndarray)" args -> IO ()
-scatter_nd_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "scatter_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_gather_nd(ndarray)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-_backward_gather_nd ::
-                    forall args . Fullfilled "_backward_gather_nd(ndarray)" args =>
-                      ArgsHMap "_backward_gather_nd(ndarray)" args -> IO [NDArrayHandle]
-_backward_gather_nd args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gather_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_gather_nd_upd ::
-                        forall args . Fullfilled "_backward_gather_nd(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_gather_nd(ndarray)" args -> IO ()
-_backward_gather_nd_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gather_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_set_nd(ndarray)" =
-     '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-_scatter_set_nd ::
-                forall args . Fullfilled "_scatter_set_nd(ndarray)" args =>
-                  ArgsHMap "_scatter_set_nd(ndarray)" args -> IO [NDArrayHandle]
-_scatter_set_nd args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_set_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_set_nd_upd ::
-                    forall args . Fullfilled "_scatter_set_nd(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_scatter_set_nd(ndarray)" args -> IO ()
-_scatter_set_nd_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_set_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_equal ::
-                forall args . Fullfilled "broadcast_equal(ndarray)" args =>
-                  ArgsHMap "broadcast_equal(ndarray)" args -> IO [NDArrayHandle]
-broadcast_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_equal_upd ::
-                    forall args . Fullfilled "broadcast_equal(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "broadcast_equal(ndarray)" args -> IO ()
-broadcast_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_not_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_not_equal ::
-                    forall args . Fullfilled "broadcast_not_equal(ndarray)" args =>
-                      ArgsHMap "broadcast_not_equal(ndarray)" args -> IO [NDArrayHandle]
-broadcast_not_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_not_equal_upd ::
-                        forall args . Fullfilled "broadcast_not_equal(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "broadcast_not_equal(ndarray)" args -> IO ()
-broadcast_not_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_greater(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_greater ::
-                  forall args . Fullfilled "broadcast_greater(ndarray)" args =>
-                    ArgsHMap "broadcast_greater(ndarray)" args -> IO [NDArrayHandle]
-broadcast_greater args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_greater_upd ::
-                      forall args . Fullfilled "broadcast_greater(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "broadcast_greater(ndarray)" args -> IO ()
-broadcast_greater_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_greater_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_greater_equal ::
-                        forall args . Fullfilled "broadcast_greater_equal(ndarray)" args =>
-                          ArgsHMap "broadcast_greater_equal(ndarray)" args ->
-                            IO [NDArrayHandle]
-broadcast_greater_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_greater_equal_upd ::
-                            forall args . Fullfilled "broadcast_greater_equal(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "broadcast_greater_equal(ndarray)" args -> IO ()
-broadcast_greater_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_lesser(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_lesser ::
-                 forall args . Fullfilled "broadcast_lesser(ndarray)" args =>
-                   ArgsHMap "broadcast_lesser(ndarray)" args -> IO [NDArrayHandle]
-broadcast_lesser args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_lesser_upd ::
-                     forall args . Fullfilled "broadcast_lesser(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "broadcast_lesser(ndarray)" args -> IO ()
-broadcast_lesser_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_lesser_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_lesser_equal ::
-                       forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args =>
-                         ArgsHMap "broadcast_lesser_equal(ndarray)" args ->
-                           IO [NDArrayHandle]
-broadcast_lesser_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_lesser_equal_upd ::
-                           forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "broadcast_lesser_equal(ndarray)" args -> IO ()
-broadcast_lesser_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_logical_and(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_logical_and ::
-                      forall args . Fullfilled "broadcast_logical_and(ndarray)" args =>
-                        ArgsHMap "broadcast_logical_and(ndarray)" args ->
-                          IO [NDArrayHandle]
-broadcast_logical_and args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_and"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_logical_and_upd ::
-                          forall args . Fullfilled "broadcast_logical_and(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "broadcast_logical_and(ndarray)" args -> IO ()
-broadcast_logical_and_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_and"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_logical_or(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_logical_or ::
-                     forall args . Fullfilled "broadcast_logical_or(ndarray)" args =>
-                       ArgsHMap "broadcast_logical_or(ndarray)" args -> IO [NDArrayHandle]
-broadcast_logical_or args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_or"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_logical_or_upd ::
-                         forall args . Fullfilled "broadcast_logical_or(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "broadcast_logical_or(ndarray)" args -> IO ()
-broadcast_logical_or_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_or"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_logical_xor(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_logical_xor ::
-                      forall args . Fullfilled "broadcast_logical_xor(ndarray)" args =>
-                        ArgsHMap "broadcast_logical_xor(ndarray)" args ->
-                          IO [NDArrayHandle]
-broadcast_logical_xor args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_xor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_logical_xor_upd ::
-                          forall args . Fullfilled "broadcast_logical_xor(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "broadcast_logical_xor(ndarray)" args -> IO ()
-broadcast_logical_xor_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_xor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_plus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_plus_scalar ::
-             forall args . Fullfilled "_plus_scalar(ndarray)" args =>
-               ArgsHMap "_plus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_plus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_plus_scalar_upd ::
-                 forall args . Fullfilled "_plus_scalar(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_plus_scalar(ndarray)" args -> IO ()
-_plus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_minus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_minus_scalar ::
-              forall args . Fullfilled "_minus_scalar(ndarray)" args =>
-                ArgsHMap "_minus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_minus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_minus_scalar_upd ::
-                  forall args . Fullfilled "_minus_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_minus_scalar(ndarray)" args -> IO ()
-_minus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rminus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rminus_scalar ::
-               forall args . Fullfilled "_rminus_scalar(ndarray)" args =>
-                 ArgsHMap "_rminus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rminus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rminus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rminus_scalar_upd ::
-                   forall args . Fullfilled "_rminus_scalar(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_rminus_scalar(ndarray)" args -> IO ()
-_rminus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rminus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_mul_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_mul_scalar ::
-            forall args . Fullfilled "_mul_scalar(ndarray)" args =>
-              ArgsHMap "_mul_scalar(ndarray)" args -> IO [NDArrayHandle]
-_mul_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_mul_scalar_upd ::
-                forall args . Fullfilled "_mul_scalar(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_mul_scalar(ndarray)" args -> IO ()
-_mul_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mul_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_backward_mul_scalar ::
-                     forall args . Fullfilled "_backward_mul_scalar(ndarray)" args =>
-                       ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO [NDArrayHandle]
-_backward_mul_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mul_scalar_upd ::
-                         forall args . Fullfilled "_backward_mul_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO ()
-_backward_mul_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_div_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_div_scalar ::
-            forall args . Fullfilled "_div_scalar(ndarray)" args =>
-              ArgsHMap "_div_scalar(ndarray)" args -> IO [NDArrayHandle]
-_div_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_div_scalar_upd ::
-                forall args . Fullfilled "_div_scalar(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_div_scalar(ndarray)" args -> IO ()
-_div_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_div_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_backward_div_scalar ::
-                     forall args . Fullfilled "_backward_div_scalar(ndarray)" args =>
-                       ArgsHMap "_backward_div_scalar(ndarray)" args -> IO [NDArrayHandle]
-_backward_div_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_div_scalar_upd ::
-                         forall args . Fullfilled "_backward_div_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_div_scalar(ndarray)" args -> IO ()
-_backward_div_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rdiv_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rdiv_scalar ::
-             forall args . Fullfilled "_rdiv_scalar(ndarray)" args =>
-               ArgsHMap "_rdiv_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rdiv_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rdiv_scalar_upd ::
-                 forall args . Fullfilled "_rdiv_scalar(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_rdiv_scalar(ndarray)" args -> IO ()
-_rdiv_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rdiv_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rdiv_scalar ::
-                      forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args =>
-                        ArgsHMap "_backward_rdiv_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_rdiv_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rdiv_scalar_upd ::
-                          forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> IO ()
-_backward_rdiv_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_mod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_mod_scalar ::
-            forall args . Fullfilled "_mod_scalar(ndarray)" args =>
-              ArgsHMap "_mod_scalar(ndarray)" args -> IO [NDArrayHandle]
-_mod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_mod_scalar_upd ::
-                forall args . Fullfilled "_mod_scalar(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_mod_scalar(ndarray)" args -> IO ()
-_mod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_mod_scalar ::
-                     forall args . Fullfilled "_backward_mod_scalar(ndarray)" args =>
-                       ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO [NDArrayHandle]
-_backward_mod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mod_scalar_upd ::
-                         forall args . Fullfilled "_backward_mod_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO ()
-_backward_mod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rmod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rmod_scalar ::
-             forall args . Fullfilled "_rmod_scalar(ndarray)" args =>
-               ArgsHMap "_rmod_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rmod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rmod_scalar_upd ::
-                 forall args . Fullfilled "_rmod_scalar(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_rmod_scalar(ndarray)" args -> IO ()
-_rmod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rmod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rmod_scalar ::
-                      forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args =>
-                        ArgsHMap "_backward_rmod_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_rmod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rmod_scalar_upd ::
-                          forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_rmod_scalar(ndarray)" args -> IO ()
-_backward_rmod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_ravel_multi_index(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-_ravel_multi_index ::
-                   forall args . Fullfilled "_ravel_multi_index(ndarray)" args =>
-                     ArgsHMap "_ravel_multi_index(ndarray)" args -> IO [NDArrayHandle]
-_ravel_multi_index args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ravel_multi_index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_ravel_multi_index_upd ::
-                       forall args . Fullfilled "_ravel_multi_index(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_ravel_multi_index(ndarray)" args -> IO ()
-_ravel_multi_index_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ravel_multi_index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_unravel_index(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-_unravel_index ::
-               forall args . Fullfilled "_unravel_index(ndarray)" args =>
-                 ArgsHMap "_unravel_index(ndarray)" args -> IO [NDArrayHandle]
-_unravel_index args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_unravel_index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_unravel_index_upd ::
-                   forall args . Fullfilled "_unravel_index(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_unravel_index(ndarray)" args -> IO ()
-_unravel_index_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_unravel_index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argmax(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-argmax ::
-       forall args . Fullfilled "argmax(ndarray)" args =>
-         ArgsHMap "argmax(ndarray)" args -> IO [NDArrayHandle]
-argmax args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argmax_upd ::
-           forall args . Fullfilled "argmax(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "argmax(ndarray)" args -> IO ()
-argmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argmin(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-argmin ::
-       forall args . Fullfilled "argmin(ndarray)" args =>
-         ArgsHMap "argmin(ndarray)" args -> IO [NDArrayHandle]
-argmin args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argmin_upd ::
-           forall args . Fullfilled "argmin(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "argmin(ndarray)" args -> IO ()
-argmin_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argmax_channel(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-argmax_channel ::
-               forall args . Fullfilled "argmax_channel(ndarray)" args =>
-                 ArgsHMap "argmax_channel(ndarray)" args -> IO [NDArrayHandle]
-argmax_channel args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax_channel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argmax_channel_upd ::
-                   forall args . Fullfilled "argmax_channel(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "argmax_channel(ndarray)" args -> IO ()
-argmax_channel_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax_channel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "pick(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("mode", AttrOpt (EnumType '["clip", "wrap"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("index", AttrOpt NDArrayHandle)]
-
-pick ::
-     forall args . Fullfilled "pick(ndarray)" args =>
-       ArgsHMap "pick(ndarray)" args -> IO [NDArrayHandle]
-pick args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-pick_upd ::
-         forall args . Fullfilled "pick(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "pick(ndarray)" args -> IO ()
-pick_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_pick(ndarray)" = '[]
-
-_backward_pick ::
-               forall args . Fullfilled "_backward_pick(ndarray)" args =>
-                 ArgsHMap "_backward_pick(ndarray)" args -> IO [NDArrayHandle]
-_backward_pick args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_pick_upd ::
-                   forall args . Fullfilled "_backward_pick(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_pick(ndarray)" args -> IO ()
-_backward_pick_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sparse_retain(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-_sparse_retain ::
-               forall args . Fullfilled "_sparse_retain(ndarray)" args =>
-                 ArgsHMap "_sparse_retain(ndarray)" args -> IO [NDArrayHandle]
-_sparse_retain args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sparse_retain_upd ::
-                   forall args . Fullfilled "_sparse_retain(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_sparse_retain(ndarray)" args -> IO ()
-_sparse_retain_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sparse_retain(ndarray)" =
-     '[]
-
-_backward_sparse_retain ::
-                        forall args . Fullfilled "_backward_sparse_retain(ndarray)" args =>
-                          ArgsHMap "_backward_sparse_retain(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_sparse_retain args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sparse_retain_upd ::
-                            forall args . Fullfilled "_backward_sparse_retain(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_sparse_retain(ndarray)" args -> IO ()
-_backward_sparse_retain_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_where(ndarray)" =
-     '[ '("condition", AttrOpt NDArrayHandle),
-        '("x", AttrOpt NDArrayHandle), '("y", AttrOpt NDArrayHandle)]
-
-_where ::
-       forall args . Fullfilled "_where(ndarray)" args =>
-         ArgsHMap "_where(ndarray)" args -> IO [NDArrayHandle]
-_where args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle),
-               ("x",) <$> (args !? #x :: Maybe NDArrayHandle),
-               ("y",) <$> (args !? #y :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_where_upd ::
-           forall args . Fullfilled "_where(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_where(ndarray)" args -> IO ()
-_where_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle),
-               ("x",) <$> (args !? #x :: Maybe NDArrayHandle),
-               ("y",) <$> (args !? #y :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_where(ndarray)" = '[]
-
-_backward_where ::
-                forall args . Fullfilled "_backward_where(ndarray)" args =>
-                  ArgsHMap "_backward_where(ndarray)" args -> IO [NDArrayHandle]
-_backward_where args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_where_upd ::
-                    forall args . Fullfilled "_backward_where(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_where(ndarray)" args -> IO ()
-_backward_where_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "diag(ndarray)" =
-     '[ '("k", AttrOpt (Maybe Int)), '("data", AttrOpt NDArrayHandle)]
-
-diag ::
-     forall args . Fullfilled "diag(ndarray)" args =>
-       ArgsHMap "diag(ndarray)" args -> IO [NDArrayHandle]
-diag args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "diag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-diag_upd ::
-         forall args . Fullfilled "diag(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "diag(ndarray)" args -> IO ()
-diag_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "diag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_diag(ndarray)" = '[]
-
-_backward_diag ::
-               forall args . Fullfilled "_backward_diag(ndarray)" args =>
-                 ArgsHMap "_backward_diag(ndarray)" args -> IO [NDArrayHandle]
-_backward_diag args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_diag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_diag_upd ::
-                   forall args . Fullfilled "_backward_diag(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_diag(ndarray)" args -> IO ()
-_backward_diag_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_diag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_maximum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_maximum_scalar ::
-                forall args . Fullfilled "_maximum_scalar(ndarray)" args =>
-                  ArgsHMap "_maximum_scalar(ndarray)" args -> IO [NDArrayHandle]
-_maximum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_maximum_scalar_upd ::
-                    forall args . Fullfilled "_maximum_scalar(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_maximum_scalar(ndarray)" args -> IO ()
-_maximum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_maximum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_maximum_scalar ::
-                         forall args .
-                           Fullfilled "_backward_maximum_scalar(ndarray)" args =>
-                           ArgsHMap "_backward_maximum_scalar(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_maximum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_maximum_scalar_upd ::
-                             forall args .
-                               Fullfilled "_backward_maximum_scalar(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_maximum_scalar(ndarray)" args -> IO ()
-_backward_maximum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_minimum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_minimum_scalar ::
-                forall args . Fullfilled "_minimum_scalar(ndarray)" args =>
-                  ArgsHMap "_minimum_scalar(ndarray)" args -> IO [NDArrayHandle]
-_minimum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_minimum_scalar_upd ::
-                    forall args . Fullfilled "_minimum_scalar(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_minimum_scalar(ndarray)" args -> IO ()
-_minimum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_minimum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_minimum_scalar ::
-                         forall args .
-                           Fullfilled "_backward_minimum_scalar(ndarray)" args =>
-                           ArgsHMap "_backward_minimum_scalar(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_minimum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_minimum_scalar_upd ::
-                             forall args .
-                               Fullfilled "_backward_minimum_scalar(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_minimum_scalar(ndarray)" args -> IO ()
-_backward_minimum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_power_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_power_scalar ::
-              forall args . Fullfilled "_power_scalar(ndarray)" args =>
-                ArgsHMap "_power_scalar(ndarray)" args -> IO [NDArrayHandle]
-_power_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_power_scalar_upd ::
-                  forall args . Fullfilled "_power_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_power_scalar(ndarray)" args -> IO ()
-_power_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_power_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_power_scalar ::
-                       forall args . Fullfilled "_backward_power_scalar(ndarray)" args =>
-                         ArgsHMap "_backward_power_scalar(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_power_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_power_scalar_upd ::
-                           forall args . Fullfilled "_backward_power_scalar(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_power_scalar(ndarray)" args -> IO ()
-_backward_power_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rpower_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rpower_scalar ::
-               forall args . Fullfilled "_rpower_scalar(ndarray)" args =>
-                 ArgsHMap "_rpower_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rpower_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rpower_scalar_upd ::
-                   forall args . Fullfilled "_rpower_scalar(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_rpower_scalar(ndarray)" args -> IO ()
-_rpower_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rpower_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rpower_scalar ::
-                        forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args =>
-                          ArgsHMap "_backward_rpower_scalar(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_rpower_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rpower_scalar_upd ::
-                            forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_rpower_scalar(ndarray)" args -> IO ()
-_backward_rpower_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_hypot_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_hypot_scalar ::
-              forall args . Fullfilled "_hypot_scalar(ndarray)" args =>
-                ArgsHMap "_hypot_scalar(ndarray)" args -> IO [NDArrayHandle]
-_hypot_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_hypot_scalar_upd ::
-                  forall args . Fullfilled "_hypot_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_hypot_scalar(ndarray)" args -> IO ()
-_hypot_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_hypot_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_hypot_scalar ::
-                       forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args =>
-                         ArgsHMap "_backward_hypot_scalar(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_hypot_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_hypot_scalar_upd ::
-                           forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_hypot_scalar(ndarray)" args -> IO ()
-_backward_hypot_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "smooth_l1(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-smooth_l1 ::
-          forall args . Fullfilled "smooth_l1(ndarray)" args =>
-            ArgsHMap "smooth_l1(ndarray)" args -> IO [NDArrayHandle]
-smooth_l1 args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-smooth_l1_upd ::
-              forall args . Fullfilled "smooth_l1(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "smooth_l1(ndarray)" args -> IO ()
-smooth_l1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_smooth_l1(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_smooth_l1 ::
-                    forall args . Fullfilled "_backward_smooth_l1(ndarray)" args =>
-                      ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO [NDArrayHandle]
-_backward_smooth_l1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_smooth_l1_upd ::
-                        forall args . Fullfilled "_backward_smooth_l1(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO ()
-_backward_smooth_l1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "topk(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),
-        '("ret_typ",
-          AttrOpt (EnumType '["both", "indices", "mask", "value"])),
-        '("is_ascend", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-topk ::
-     forall args . Fullfilled "topk(ndarray)" args =>
-       ArgsHMap "topk(ndarray)" args -> IO [NDArrayHandle]
-topk args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ret_typ",) . showValue <$>
-                 (args !? #ret_typ ::
-                    Maybe (EnumType '["both", "indices", "mask", "value"])),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-topk_upd ::
-         forall args . Fullfilled "topk(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "topk(ndarray)" args -> IO ()
-topk_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ret_typ",) . showValue <$>
-                 (args !? #ret_typ ::
-                    Maybe (EnumType '["both", "indices", "mask", "value"])),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_topk(ndarray)" = '[]
-
-_backward_topk ::
-               forall args . Fullfilled "_backward_topk(ndarray)" args =>
-                 ArgsHMap "_backward_topk(ndarray)" args -> IO [NDArrayHandle]
-_backward_topk args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_topk_upd ::
-                   forall args . Fullfilled "_backward_topk(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_topk(ndarray)" args -> IO ()
-_backward_topk_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sort(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-sort ::
-     forall args . Fullfilled "sort(ndarray)" args =>
-       ArgsHMap "sort(ndarray)" args -> IO [NDArrayHandle]
-sort args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sort_upd ::
-         forall args . Fullfilled "sort(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sort(ndarray)" args -> IO ()
-sort_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argsort(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-argsort ::
-        forall args . Fullfilled "argsort(ndarray)" args =>
-          ArgsHMap "argsort(ndarray)" args -> IO [NDArrayHandle]
-argsort args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argsort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argsort_upd ::
-            forall args . Fullfilled "argsort(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "argsort(ndarray)" args -> IO ()
-argsort_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argsort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Reshape(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),
-        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Reshape ::
-         forall args . Fullfilled "_Reshape(ndarray)" args =>
-           ArgsHMap "_Reshape(ndarray)" args -> IO [NDArrayHandle]
-_Reshape args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("keep_highest",) . showValue <$>
-                 (args !? #keep_highest :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Reshape"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Reshape_upd ::
-             forall args . Fullfilled "_Reshape(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Reshape(ndarray)" args -> IO ()
-_Reshape_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("keep_highest",) . showValue <$>
-                 (args !? #keep_highest :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Reshape"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Flatten(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_Flatten ::
-         forall args . Fullfilled "_Flatten(ndarray)" args =>
-           ArgsHMap "_Flatten(ndarray)" args -> IO [NDArrayHandle]
-_Flatten args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Flatten"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Flatten_upd ::
-             forall args . Fullfilled "_Flatten(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Flatten(ndarray)" args -> IO ()
-_Flatten_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Flatten"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "transpose(ndarray)" =
-     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-transpose ::
-          forall args . Fullfilled "transpose(ndarray)" args =>
-            ArgsHMap "transpose(ndarray)" args -> IO [NDArrayHandle]
-transpose args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "transpose"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-transpose_upd ::
-              forall args . Fullfilled "transpose(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "transpose(ndarray)" args -> IO ()
-transpose_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "transpose"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "expand_dims(ndarray)" =
-     '[ '("axis", AttrReq Int), '("data", AttrOpt NDArrayHandle)]
-
-expand_dims ::
-            forall args . Fullfilled "expand_dims(ndarray)" args =>
-              ArgsHMap "expand_dims(ndarray)" args -> IO [NDArrayHandle]
-expand_dims args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expand_dims"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-expand_dims_upd ::
-                forall args . Fullfilled "expand_dims(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "expand_dims(ndarray)" args -> IO ()
-expand_dims_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expand_dims"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "slice(ndarray)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-slice ::
-      forall args . Fullfilled "slice(ndarray)" args =>
-        ArgsHMap "slice(ndarray)" args -> IO [NDArrayHandle]
-slice args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-slice_upd ::
-          forall args . Fullfilled "slice(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "slice(ndarray)" args -> IO ()
-slice_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_slice(ndarray)" = '[]
-
-_backward_slice ::
-                forall args . Fullfilled "_backward_slice(ndarray)" args =>
-                  ArgsHMap "_backward_slice(ndarray)" args -> IO [NDArrayHandle]
-_backward_slice args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_slice_upd ::
-                    forall args . Fullfilled "_backward_slice(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_slice(ndarray)" args -> IO ()
-_backward_slice_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_slice_assign(ndarray)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_slice_assign ::
-              forall args . Fullfilled "_slice_assign(ndarray)" args =>
-                ArgsHMap "_slice_assign(ndarray)" args -> IO [NDArrayHandle]
-_slice_assign args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_slice_assign_upd ::
-                  forall args . Fullfilled "_slice_assign(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_slice_assign(ndarray)" args -> IO ()
-_slice_assign_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_slice_assign_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("begin", AttrReq [Int]),
-        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_slice_assign_scalar ::
-                     forall args . Fullfilled "_slice_assign_scalar(ndarray)" args =>
-                       ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO [NDArrayHandle]
-_slice_assign_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_slice_assign_scalar_upd ::
-                         forall args . Fullfilled "_slice_assign_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO ()
-_slice_assign_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "slice_axis(ndarray)" =
-     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),
-        '("end", AttrReq (Maybe Int)), '("data", AttrOpt NDArrayHandle)]
-
-slice_axis ::
-           forall args . Fullfilled "slice_axis(ndarray)" args =>
-             ArgsHMap "slice_axis(ndarray)" args -> IO [NDArrayHandle]
-slice_axis args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),
-               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-slice_axis_upd ::
-               forall args . Fullfilled "slice_axis(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "slice_axis(ndarray)" args -> IO ()
-slice_axis_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),
-               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_slice_axis(ndarray)" = '[]
-
-_backward_slice_axis ::
-                     forall args . Fullfilled "_backward_slice_axis(ndarray)" args =>
-                       ArgsHMap "_backward_slice_axis(ndarray)" args -> IO [NDArrayHandle]
-_backward_slice_axis args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_slice_axis_upd ::
-                         forall args . Fullfilled "_backward_slice_axis(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_slice_axis(ndarray)" args -> IO ()
-_backward_slice_axis_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "slice_like(ndarray)" =
-     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle),
-        '("shape_like", AttrOpt NDArrayHandle)]
-
-slice_like ::
-           forall args . Fullfilled "slice_like(ndarray)" args =>
-             ArgsHMap "slice_like(ndarray)" args -> IO [NDArrayHandle]
-slice_like args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-slice_like_upd ::
-               forall args . Fullfilled "slice_like(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "slice_like(ndarray)" args -> IO ()
-slice_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_slice_like(ndarray)" = '[]
-
-_backward_slice_like ::
-                     forall args . Fullfilled "_backward_slice_like(ndarray)" args =>
-                       ArgsHMap "_backward_slice_like(ndarray)" args -> IO [NDArrayHandle]
-_backward_slice_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_slice_like_upd ::
-                         forall args . Fullfilled "_backward_slice_like(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_slice_like(ndarray)" args -> IO ()
-_backward_slice_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "clip(ndarray)" =
-     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-clip ::
-     forall args . Fullfilled "clip(ndarray)" args =>
-       ArgsHMap "clip(ndarray)" args -> IO [NDArrayHandle]
-clip args
-  = let scalarArgs
-          = catMaybes
-              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),
-               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-clip_upd ::
-         forall args . Fullfilled "clip(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "clip(ndarray)" args -> IO ()
-clip_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),
-               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_clip(ndarray)" = '[]
-
-_backward_clip ::
-               forall args . Fullfilled "_backward_clip(ndarray)" args =>
-                 ArgsHMap "_backward_clip(ndarray)" args -> IO [NDArrayHandle]
-_backward_clip args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_clip_upd ::
-                   forall args . Fullfilled "_backward_clip(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_clip(ndarray)" args -> IO ()
-_backward_clip_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "repeat(ndarray)" =
-     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),
-        '("data", AttrOpt NDArrayHandle)]
-
-repeat ::
-       forall args . Fullfilled "repeat(ndarray)" args =>
-         ArgsHMap "repeat(ndarray)" args -> IO [NDArrayHandle]
-repeat args
-  = let scalarArgs
-          = catMaybes
-              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-repeat_upd ::
-           forall args . Fullfilled "repeat(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "repeat(ndarray)" args -> IO ()
-repeat_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_repeat(ndarray)" = '[]
-
-_backward_repeat ::
-                 forall args . Fullfilled "_backward_repeat(ndarray)" args =>
-                   ArgsHMap "_backward_repeat(ndarray)" args -> IO [NDArrayHandle]
-_backward_repeat args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_repeat_upd ::
-                     forall args . Fullfilled "_backward_repeat(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_repeat(ndarray)" args -> IO ()
-_backward_repeat_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "tile(ndarray)" =
-     '[ '("reps", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)]
-
-tile ::
-     forall args . Fullfilled "tile(ndarray)" args =>
-       ArgsHMap "tile(ndarray)" args -> IO [NDArrayHandle]
-tile args
-  = let scalarArgs
-          = catMaybes
-              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-tile_upd ::
-         forall args . Fullfilled "tile(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "tile(ndarray)" args -> IO ()
-tile_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_tile(ndarray)" = '[]
-
-_backward_tile ::
-               forall args . Fullfilled "_backward_tile(ndarray)" args =>
-                 ArgsHMap "_backward_tile(ndarray)" args -> IO [NDArrayHandle]
-_backward_tile args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_tile_upd ::
-                   forall args . Fullfilled "_backward_tile(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_tile(ndarray)" args -> IO ()
-_backward_tile_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "reverse(ndarray)" =
-     '[ '("axis", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)]
-
-reverse ::
-        forall args . Fullfilled "reverse(ndarray)" args =>
-          ArgsHMap "reverse(ndarray)" args -> IO [NDArrayHandle]
-reverse args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-reverse_upd ::
-            forall args . Fullfilled "reverse(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "reverse(ndarray)" args -> IO ()
-reverse_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_reverse(ndarray)" = '[]
-
-_backward_reverse ::
-                  forall args . Fullfilled "_backward_reverse(ndarray)" args =>
-                    ArgsHMap "_backward_reverse(ndarray)" args -> IO [NDArrayHandle]
-_backward_reverse args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_reverse_upd ::
-                      forall args . Fullfilled "_backward_reverse(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_reverse(ndarray)" args -> IO ()
-_backward_reverse_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "stack(ndarray)" =
-     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-stack ::
-      forall args . Fullfilled "stack(ndarray)" args =>
-        ArgsHMap "stack(ndarray)" args -> IO [NDArrayHandle]
-stack args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "stack"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-stack_upd ::
-          forall args . Fullfilled "stack(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "stack(ndarray)" args -> IO ()
-stack_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "stack"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_stack(ndarray)" = '[]
-
-_backward_stack ::
-                forall args . Fullfilled "_backward_stack(ndarray)" args =>
-                  ArgsHMap "_backward_stack(ndarray)" args -> IO [NDArrayHandle]
-_backward_stack args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_stack"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_stack_upd ::
-                    forall args . Fullfilled "_backward_stack(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_stack(ndarray)" args -> IO ()
-_backward_stack_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_stack"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "squeeze(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])),
-        '("data", AttrOpt [NDArrayHandle])]
-
-squeeze ::
-        forall args . Fullfilled "squeeze(ndarray)" args =>
-          ArgsHMap "squeeze(ndarray)" args -> IO [NDArrayHandle]
-squeeze args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "squeeze"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-squeeze_upd ::
-            forall args . Fullfilled "squeeze(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "squeeze(ndarray)" args -> IO ()
-squeeze_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "squeeze"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_squeeze(ndarray)" = '[]
-
-_backward_squeeze ::
-                  forall args . Fullfilled "_backward_squeeze(ndarray)" args =>
-                    ArgsHMap "_backward_squeeze(ndarray)" args -> IO [NDArrayHandle]
-_backward_squeeze args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_squeeze"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_squeeze_upd ::
-                      forall args . Fullfilled "_backward_squeeze(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_squeeze(ndarray)" args -> IO ()
-_backward_squeeze_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_squeeze"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "depth_to_space(ndarray)" =
-     '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)]
-
-depth_to_space ::
-               forall args . Fullfilled "depth_to_space(ndarray)" args =>
-                 ArgsHMap "depth_to_space(ndarray)" args -> IO [NDArrayHandle]
-depth_to_space args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "depth_to_space"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-depth_to_space_upd ::
-                   forall args . Fullfilled "depth_to_space(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "depth_to_space(ndarray)" args -> IO ()
-depth_to_space_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "depth_to_space"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "space_to_depth(ndarray)" =
-     '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)]
-
-space_to_depth ::
-               forall args . Fullfilled "space_to_depth(ndarray)" args =>
-                 ArgsHMap "space_to_depth(ndarray)" args -> IO [NDArrayHandle]
-space_to_depth args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "space_to_depth"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-space_to_depth_upd ::
-                   forall args . Fullfilled "space_to_depth(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "space_to_depth(ndarray)" args -> IO ()
-space_to_depth_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "space_to_depth"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "dot(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),
-        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-dot ::
-    forall args . Fullfilled "dot(ndarray)" args =>
-      ArgsHMap "dot(ndarray)" args -> IO [NDArrayHandle]
-dot args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-dot_upd ::
-        forall args . Fullfilled "dot(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "dot(ndarray)" args -> IO ()
-dot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_dot(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-
-_backward_dot ::
-              forall args . Fullfilled "_backward_dot(ndarray)" args =>
-                ArgsHMap "_backward_dot(ndarray)" args -> IO [NDArrayHandle]
-_backward_dot args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_dot_upd ::
-                  forall args . Fullfilled "_backward_dot(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_dot(ndarray)" args -> IO ()
-_backward_dot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "batch_dot(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),
-        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-batch_dot ::
-          forall args . Fullfilled "batch_dot(ndarray)" args =>
-            ArgsHMap "batch_dot(ndarray)" args -> IO [NDArrayHandle]
-batch_dot args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-batch_dot_upd ::
-              forall args . Fullfilled "batch_dot(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "batch_dot(ndarray)" args -> IO ()
-batch_dot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_batch_dot(ndarray)" = '[]
-
-_backward_batch_dot ::
-                    forall args . Fullfilled "_backward_batch_dot(ndarray)" args =>
-                      ArgsHMap "_backward_batch_dot(ndarray)" args -> IO [NDArrayHandle]
-_backward_batch_dot args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_batch_dot_upd ::
-                        forall args . Fullfilled "_backward_batch_dot(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_batch_dot(ndarray)" args -> IO ()
-_backward_batch_dot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sin(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sin ::
-    forall args . Fullfilled "sin(ndarray)" args =>
-      ArgsHMap "sin(ndarray)" args -> IO [NDArrayHandle]
-sin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sin_upd ::
-        forall args . Fullfilled "sin(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "sin(ndarray)" args -> IO ()
-sin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sin(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sin ::
-              forall args . Fullfilled "_backward_sin(ndarray)" args =>
-                ArgsHMap "_backward_sin(ndarray)" args -> IO [NDArrayHandle]
-_backward_sin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sin_upd ::
-                  forall args . Fullfilled "_backward_sin(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_sin(ndarray)" args -> IO ()
-_backward_sin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cos(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-cos ::
-    forall args . Fullfilled "cos(ndarray)" args =>
-      ArgsHMap "cos(ndarray)" args -> IO [NDArrayHandle]
-cos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cos_upd ::
-        forall args . Fullfilled "cos(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "cos(ndarray)" args -> IO ()
-cos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cos(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_cos ::
-              forall args . Fullfilled "_backward_cos(ndarray)" args =>
-                ArgsHMap "_backward_cos(ndarray)" args -> IO [NDArrayHandle]
-_backward_cos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cos_upd ::
-                  forall args . Fullfilled "_backward_cos(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_cos(ndarray)" args -> IO ()
-_backward_cos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "tan(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-tan ::
-    forall args . Fullfilled "tan(ndarray)" args =>
-      ArgsHMap "tan(ndarray)" args -> IO [NDArrayHandle]
-tan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-tan_upd ::
-        forall args . Fullfilled "tan(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "tan(ndarray)" args -> IO ()
-tan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_tan(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_tan ::
-              forall args . Fullfilled "_backward_tan(ndarray)" args =>
-                ArgsHMap "_backward_tan(ndarray)" args -> IO [NDArrayHandle]
-_backward_tan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_tan_upd ::
-                  forall args . Fullfilled "_backward_tan(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_tan(ndarray)" args -> IO ()
-_backward_tan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arcsin(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arcsin ::
-       forall args . Fullfilled "arcsin(ndarray)" args =>
-         ArgsHMap "arcsin(ndarray)" args -> IO [NDArrayHandle]
-arcsin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arcsin_upd ::
-           forall args . Fullfilled "arcsin(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "arcsin(ndarray)" args -> IO ()
-arcsin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arcsin(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arcsin ::
-                 forall args . Fullfilled "_backward_arcsin(ndarray)" args =>
-                   ArgsHMap "_backward_arcsin(ndarray)" args -> IO [NDArrayHandle]
-_backward_arcsin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arcsin_upd ::
-                     forall args . Fullfilled "_backward_arcsin(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_arcsin(ndarray)" args -> IO ()
-_backward_arcsin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arccos(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arccos ::
-       forall args . Fullfilled "arccos(ndarray)" args =>
-         ArgsHMap "arccos(ndarray)" args -> IO [NDArrayHandle]
-arccos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arccos_upd ::
-           forall args . Fullfilled "arccos(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "arccos(ndarray)" args -> IO ()
-arccos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arccos(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arccos ::
-                 forall args . Fullfilled "_backward_arccos(ndarray)" args =>
-                   ArgsHMap "_backward_arccos(ndarray)" args -> IO [NDArrayHandle]
-_backward_arccos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arccos_upd ::
-                     forall args . Fullfilled "_backward_arccos(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_arccos(ndarray)" args -> IO ()
-_backward_arccos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arctan(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arctan ::
-       forall args . Fullfilled "arctan(ndarray)" args =>
-         ArgsHMap "arctan(ndarray)" args -> IO [NDArrayHandle]
-arctan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arctan_upd ::
-           forall args . Fullfilled "arctan(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "arctan(ndarray)" args -> IO ()
-arctan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arctan(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arctan ::
-                 forall args . Fullfilled "_backward_arctan(ndarray)" args =>
-                   ArgsHMap "_backward_arctan(ndarray)" args -> IO [NDArrayHandle]
-_backward_arctan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arctan_upd ::
-                     forall args . Fullfilled "_backward_arctan(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_arctan(ndarray)" args -> IO ()
-_backward_arctan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "degrees(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-degrees ::
-        forall args . Fullfilled "degrees(ndarray)" args =>
-          ArgsHMap "degrees(ndarray)" args -> IO [NDArrayHandle]
-degrees args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-degrees_upd ::
-            forall args . Fullfilled "degrees(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "degrees(ndarray)" args -> IO ()
-degrees_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_degrees(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_degrees ::
-                  forall args . Fullfilled "_backward_degrees(ndarray)" args =>
-                    ArgsHMap "_backward_degrees(ndarray)" args -> IO [NDArrayHandle]
-_backward_degrees args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_degrees_upd ::
-                      forall args . Fullfilled "_backward_degrees(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_degrees(ndarray)" args -> IO ()
-_backward_degrees_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "radians(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-radians ::
-        forall args . Fullfilled "radians(ndarray)" args =>
-          ArgsHMap "radians(ndarray)" args -> IO [NDArrayHandle]
-radians args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-radians_upd ::
-            forall args . Fullfilled "radians(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "radians(ndarray)" args -> IO ()
-radians_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_radians(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_radians ::
-                  forall args . Fullfilled "_backward_radians(ndarray)" args =>
-                    ArgsHMap "_backward_radians(ndarray)" args -> IO [NDArrayHandle]
-_backward_radians args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_radians_upd ::
-                      forall args . Fullfilled "_backward_radians(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_radians(ndarray)" args -> IO ()
-_backward_radians_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sinh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sinh ::
-     forall args . Fullfilled "sinh(ndarray)" args =>
-       ArgsHMap "sinh(ndarray)" args -> IO [NDArrayHandle]
-sinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sinh_upd ::
-         forall args . Fullfilled "sinh(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sinh(ndarray)" args -> IO ()
-sinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sinh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sinh ::
-               forall args . Fullfilled "_backward_sinh(ndarray)" args =>
-                 ArgsHMap "_backward_sinh(ndarray)" args -> IO [NDArrayHandle]
-_backward_sinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sinh_upd ::
-                   forall args . Fullfilled "_backward_sinh(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_sinh(ndarray)" args -> IO ()
-_backward_sinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cosh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-cosh ::
-     forall args . Fullfilled "cosh(ndarray)" args =>
-       ArgsHMap "cosh(ndarray)" args -> IO [NDArrayHandle]
-cosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cosh_upd ::
-         forall args . Fullfilled "cosh(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "cosh(ndarray)" args -> IO ()
-cosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cosh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_cosh ::
-               forall args . Fullfilled "_backward_cosh(ndarray)" args =>
-                 ArgsHMap "_backward_cosh(ndarray)" args -> IO [NDArrayHandle]
-_backward_cosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cosh_upd ::
-                   forall args . Fullfilled "_backward_cosh(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cosh(ndarray)" args -> IO ()
-_backward_cosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "tanh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-tanh ::
-     forall args . Fullfilled "tanh(ndarray)" args =>
-       ArgsHMap "tanh(ndarray)" args -> IO [NDArrayHandle]
-tanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-tanh_upd ::
-         forall args . Fullfilled "tanh(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "tanh(ndarray)" args -> IO ()
-tanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_tanh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_tanh ::
-               forall args . Fullfilled "_backward_tanh(ndarray)" args =>
-                 ArgsHMap "_backward_tanh(ndarray)" args -> IO [NDArrayHandle]
-_backward_tanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_tanh_upd ::
-                   forall args . Fullfilled "_backward_tanh(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_tanh(ndarray)" args -> IO ()
-_backward_tanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arcsinh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arcsinh ::
-        forall args . Fullfilled "arcsinh(ndarray)" args =>
-          ArgsHMap "arcsinh(ndarray)" args -> IO [NDArrayHandle]
-arcsinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arcsinh_upd ::
-            forall args . Fullfilled "arcsinh(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "arcsinh(ndarray)" args -> IO ()
-arcsinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arcsinh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arcsinh ::
-                  forall args . Fullfilled "_backward_arcsinh(ndarray)" args =>
-                    ArgsHMap "_backward_arcsinh(ndarray)" args -> IO [NDArrayHandle]
-_backward_arcsinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arcsinh_upd ::
-                      forall args . Fullfilled "_backward_arcsinh(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_arcsinh(ndarray)" args -> IO ()
-_backward_arcsinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arccosh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arccosh ::
-        forall args . Fullfilled "arccosh(ndarray)" args =>
-          ArgsHMap "arccosh(ndarray)" args -> IO [NDArrayHandle]
-arccosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arccosh_upd ::
-            forall args . Fullfilled "arccosh(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "arccosh(ndarray)" args -> IO ()
-arccosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arccosh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arccosh ::
-                  forall args . Fullfilled "_backward_arccosh(ndarray)" args =>
-                    ArgsHMap "_backward_arccosh(ndarray)" args -> IO [NDArrayHandle]
-_backward_arccosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arccosh_upd ::
-                      forall args . Fullfilled "_backward_arccosh(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_arccosh(ndarray)" args -> IO ()
-_backward_arccosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arctanh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arctanh ::
-        forall args . Fullfilled "arctanh(ndarray)" args =>
-          ArgsHMap "arctanh(ndarray)" args -> IO [NDArrayHandle]
-arctanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arctanh_upd ::
-            forall args . Fullfilled "arctanh(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "arctanh(ndarray)" args -> IO ()
-arctanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arctanh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arctanh ::
-                  forall args . Fullfilled "_backward_arctanh(ndarray)" args =>
-                    ArgsHMap "_backward_arctanh(ndarray)" args -> IO [NDArrayHandle]
-_backward_arctanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arctanh_upd ::
-                      forall args . Fullfilled "_backward_arctanh(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_arctanh(ndarray)" args -> IO ()
-_backward_arctanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_CTCLoss(ndarray)" =
-     '[ '("use_data_lengths", AttrOpt Bool),
-        '("use_label_lengths", AttrOpt Bool),
-        '("blank_label", AttrOpt (EnumType '["first", "last"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle),
-        '("data_lengths", AttrOpt NDArrayHandle),
-        '("label_lengths", AttrOpt NDArrayHandle)]
-
-_contrib_CTCLoss ::
-                 forall args . Fullfilled "_contrib_CTCLoss(ndarray)" args =>
-                   ArgsHMap "_contrib_CTCLoss(ndarray)" args -> IO [NDArrayHandle]
-_contrib_CTCLoss args
-  = let scalarArgs
-          = catMaybes
-              [("use_data_lengths",) . showValue <$>
-                 (args !? #use_data_lengths :: Maybe Bool),
-               ("use_label_lengths",) . showValue <$>
-                 (args !? #use_label_lengths :: Maybe Bool),
-               ("blank_label",) . showValue <$>
-                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("data_lengths",) <$>
-                 (args !? #data_lengths :: Maybe NDArrayHandle),
-               ("label_lengths",) <$>
-                 (args !? #label_lengths :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_CTCLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_CTCLoss_upd ::
-                     forall args . Fullfilled "_contrib_CTCLoss(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_contrib_CTCLoss(ndarray)" args -> IO ()
-_contrib_CTCLoss_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_data_lengths",) . showValue <$>
-                 (args !? #use_data_lengths :: Maybe Bool),
-               ("use_label_lengths",) . showValue <$>
-                 (args !? #use_label_lengths :: Maybe Bool),
-               ("blank_label",) . showValue <$>
-                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("data_lengths",) <$>
-                 (args !? #data_lengths :: Maybe NDArrayHandle),
-               ("label_lengths",) <$>
-                 (args !? #label_lengths :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_CTCLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quadratic(ndarray)" =
-     '[ '("a", AttrOpt Float), '("b", AttrOpt Float),
-        '("c", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_contrib_quadratic ::
-                   forall args . Fullfilled "_contrib_quadratic(ndarray)" args =>
-                     ArgsHMap "_contrib_quadratic(ndarray)" args -> IO [NDArrayHandle]
-_contrib_quadratic args
-  = let scalarArgs
-          = catMaybes
-              [("a",) . showValue <$> (args !? #a :: Maybe Float),
-               ("b",) . showValue <$> (args !? #b :: Maybe Float),
-               ("c",) . showValue <$> (args !? #c :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quadratic"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quadratic_upd ::
-                       forall args . Fullfilled "_contrib_quadratic(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_contrib_quadratic(ndarray)" args -> IO ()
-_contrib_quadratic_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("a",) . showValue <$> (args !? #a :: Maybe Float),
-               ("b",) . showValue <$> (args !? #b :: Maybe Float),
-               ("c",) . showValue <$> (args !? #c :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quadratic"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_backward_quadratic(ndarray)"
-     = '[]
-
-_contrib_backward_quadratic ::
-                            forall args .
-                              Fullfilled "_contrib_backward_quadratic(ndarray)" args =>
-                              ArgsHMap "_contrib_backward_quadratic(ndarray)" args ->
-                                IO [NDArrayHandle]
-_contrib_backward_quadratic args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_quadratic"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_backward_quadratic_upd ::
-                                forall args .
-                                  Fullfilled "_contrib_backward_quadratic(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_contrib_backward_quadratic(ndarray)" args -> IO ()
-_contrib_backward_quadratic_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_quadratic"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_div_sqrt_dim(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_contrib_div_sqrt_dim ::
-                      forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args =>
-                        ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args ->
-                          IO [NDArrayHandle]
-_contrib_div_sqrt_dim args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_div_sqrt_dim_upd ::
-                          forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args -> IO ()
-_contrib_div_sqrt_dim_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "khatri_rao(ndarray)" =
-     '[ '("args", AttrOpt [NDArrayHandle])]
-
-khatri_rao ::
-           forall args . Fullfilled "khatri_rao(ndarray)" args =>
-             ArgsHMap "khatri_rao(ndarray)" args -> IO [NDArrayHandle]
-khatri_rao args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "khatri_rao"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-khatri_rao_upd ::
-               forall args . Fullfilled "khatri_rao(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "khatri_rao(ndarray)" args -> IO ()
-khatri_rao_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "khatri_rao"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_ROIAlign(ndarray)" =
-     '[ '("pooled_size", AttrReq [Int]),
-        '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)]
-
-_contrib_ROIAlign ::
-                  forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args =>
-                    ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO [NDArrayHandle]
-_contrib_ROIAlign args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("sample_ratio",) . showValue <$>
-                 (args !? #sample_ratio :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ROIAlign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_ROIAlign_upd ::
-                      forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO ()
-_contrib_ROIAlign_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("sample_ratio",) . showValue <$>
-                 (args !? #sample_ratio :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ROIAlign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_ROIAlign(ndarray)" = '[]
-
-_backward_ROIAlign ::
-                   forall args . Fullfilled "_backward_ROIAlign(ndarray)" args =>
-                     ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO [NDArrayHandle]
-_backward_ROIAlign args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIAlign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_ROIAlign_upd ::
-                       forall args . Fullfilled "_backward_ROIAlign(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO ()
-_backward_ROIAlign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIAlign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_box_nms(ndarray)" =
-     '[ '("overlap_thresh", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),
-        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),
-        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),
-        '("in_format", AttrOpt (EnumType '["center", "corner"])),
-        '("out_format", AttrOpt (EnumType '["center", "corner"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_box_nms ::
-                 forall args . Fullfilled "_contrib_box_nms(ndarray)" args =>
-                   ArgsHMap "_contrib_box_nms(ndarray)" args -> IO [NDArrayHandle]
-_contrib_box_nms args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_nms"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_box_nms_upd ::
-                     forall args . Fullfilled "_contrib_box_nms(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_contrib_box_nms(ndarray)" args -> IO ()
-_contrib_box_nms_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_nms"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_contrib_box_nms(ndarray)" =
-     '[ '("overlap_thresh", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),
-        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),
-        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),
-        '("in_format", AttrOpt (EnumType '["center", "corner"])),
-        '("out_format", AttrOpt (EnumType '["center", "corner"]))]
-
-_backward_contrib_box_nms ::
-                          forall args .
-                            Fullfilled "_backward_contrib_box_nms(ndarray)" args =>
-                            ArgsHMap "_backward_contrib_box_nms(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_contrib_box_nms args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_nms"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_box_nms_upd ::
-                              forall args .
-                                Fullfilled "_backward_contrib_box_nms(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_contrib_box_nms(ndarray)" args -> IO ()
-_backward_contrib_box_nms_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_nms"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_box_iou(ndarray)" =
-     '[ '("format", AttrOpt (EnumType '["center", "corner"])),
-        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-_contrib_box_iou ::
-                 forall args . Fullfilled "_contrib_box_iou(ndarray)" args =>
-                   ArgsHMap "_contrib_box_iou(ndarray)" args -> IO [NDArrayHandle]
-_contrib_box_iou args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_iou"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_box_iou_upd ::
-                     forall args . Fullfilled "_contrib_box_iou(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_contrib_box_iou(ndarray)" args -> IO ()
-_contrib_box_iou_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_iou"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_contrib_box_iou(ndarray)" =
-     '[ '("format", AttrOpt (EnumType '["center", "corner"]))]
-
-_backward_contrib_box_iou ::
-                          forall args .
-                            Fullfilled "_backward_contrib_box_iou(ndarray)" args =>
-                            ArgsHMap "_backward_contrib_box_iou(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_contrib_box_iou args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_iou"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_box_iou_upd ::
-                              forall args .
-                                Fullfilled "_backward_contrib_box_iou(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_contrib_box_iou(ndarray)" args -> IO ()
-_backward_contrib_box_iou_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_iou"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_bipartite_matching(ndarray)"
-     =
-     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),
-        '("topk", AttrOpt Int), '("data", AttrOpt NDArrayHandle)]
-
-_contrib_bipartite_matching ::
-                            forall args .
-                              Fullfilled "_contrib_bipartite_matching(ndarray)" args =>
-                              ArgsHMap "_contrib_bipartite_matching(ndarray)" args ->
-                                IO [NDArrayHandle]
-_contrib_bipartite_matching args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_bipartite_matching"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_bipartite_matching_upd ::
-                                forall args .
-                                  Fullfilled "_contrib_bipartite_matching(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_contrib_bipartite_matching(ndarray)" args -> IO ()
-_contrib_bipartite_matching_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_bipartite_matching"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_contrib_bipartite_matching(ndarray)" =
-     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),
-        '("topk", AttrOpt Int)]
-
-_backward_contrib_bipartite_matching ::
-                                     forall args .
-                                       Fullfilled "_backward_contrib_bipartite_matching(ndarray)"
-                                         args =>
-                                       ArgsHMap "_backward_contrib_bipartite_matching(ndarray)" args
-                                         -> IO [NDArrayHandle]
-_backward_contrib_bipartite_matching args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_bipartite_matching_upd ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward_contrib_bipartite_matching(ndarray)" args =>
-                                           [NDArrayHandle] ->
-                                             ArgsHMap
-                                               "_backward_contrib_bipartite_matching(ndarray)"
-                                               args
-                                               -> IO ()
-_backward_contrib_bipartite_matching_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_BilinearResize2D(ndarray)" =
-     '[ '("height", AttrReq Int), '("width", AttrReq Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_BilinearResize2D ::
-                          forall args .
-                            Fullfilled "_contrib_BilinearResize2D(ndarray)" args =>
-                            ArgsHMap "_contrib_BilinearResize2D(ndarray)" args ->
-                              IO [NDArrayHandle]
-_contrib_BilinearResize2D args
-  = let scalarArgs
-          = catMaybes
-              [("height",) . showValue <$> (args !? #height :: Maybe Int),
-               ("width",) . showValue <$> (args !? #width :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_BilinearResize2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_BilinearResize2D_upd ::
-                              forall args .
-                                Fullfilled "_contrib_BilinearResize2D(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_contrib_BilinearResize2D(ndarray)" args -> IO ()
-_contrib_BilinearResize2D_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("height",) . showValue <$> (args !? #height :: Maybe Int),
-               ("width",) . showValue <$> (args !? #width :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_BilinearResize2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_contrib_BilinearResize2D(ndarray)" = '[]
-
-_backward_contrib_BilinearResize2D ::
-                                   forall args .
-                                     Fullfilled "_backward_contrib_BilinearResize2D(ndarray)"
-                                       args =>
-                                     ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)" args ->
-                                       IO [NDArrayHandle]
-_backward_contrib_BilinearResize2D args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_BilinearResize2D_upd ::
-                                       forall args .
-                                         Fullfilled "_backward_contrib_BilinearResize2D(ndarray)"
-                                           args =>
-                                         [NDArrayHandle] ->
-                                           ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)"
-                                             args
-                                             -> IO ()
-_backward_contrib_BilinearResize2D_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_SyncBatchNorm(ndarray)" =
-     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int),
-        '("key", AttrOpt String), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle),
-        '("moving_mean", AttrOpt NDArrayHandle),
-        '("moving_var", AttrOpt NDArrayHandle)]
-
-_contrib_SyncBatchNorm ::
-                       forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args =>
-                         ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args ->
-                           IO [NDArrayHandle]
-_contrib_SyncBatchNorm args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),
-               ("key",) . showValue <$> (args !? #key :: Maybe String)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_SyncBatchNorm_upd ::
-                           forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args -> IO ()
-_contrib_SyncBatchNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),
-               ("key",) . showValue <$> (args !? #key :: Maybe String)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_contrib_AdaptiveAvgPooling2D(ndarray)" =
-     '[ '("output_size", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_AdaptiveAvgPooling2D ::
-                              forall args .
-                                Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args =>
-                                ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args ->
-                                  IO [NDArrayHandle]
-_contrib_AdaptiveAvgPooling2D args
-  = let scalarArgs
-          = catMaybes
-              [("output_size",) . showValue <$>
-                 (args !? #output_size :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_AdaptiveAvgPooling2D_upd ::
-                                  forall args .
-                                    Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args =>
-                                    [NDArrayHandle] ->
-                                      ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args ->
-                                        IO ()
-_contrib_AdaptiveAvgPooling2D_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("output_size",) . showValue <$>
-                 (args !? #output_size :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" =
-     '[]
-
-_backward_contrib_AdaptiveAvgPooling2D ::
-                                       forall args .
-                                         Fullfilled
-                                           "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" args =>
-                                         ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"
-                                           args
-                                           -> IO [NDArrayHandle]
-_backward_contrib_AdaptiveAvgPooling2D args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_AdaptiveAvgPooling2D_upd ::
-                                           forall args .
-                                             Fullfilled
-                                               "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"
-                                               args =>
-                                             [NDArrayHandle] ->
-                                               ArgsHMap
-                                                 "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"
-                                                 args
-                                                 -> IO ()
-_backward_contrib_AdaptiveAvgPooling2D_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_to_tensor(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_to_tensor ::
-                 forall args . Fullfilled "_image_to_tensor(ndarray)" args =>
-                   ArgsHMap "_image_to_tensor(ndarray)" args -> IO [NDArrayHandle]
-_image_to_tensor args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_to_tensor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_to_tensor_upd ::
-                     forall args . Fullfilled "_image_to_tensor(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_image_to_tensor(ndarray)" args -> IO ()
-_image_to_tensor_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_to_tensor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_normalize(ndarray)" =
-     '[ '("mean", AttrReq [Float]), '("std", AttrReq [Float]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_normalize ::
-                 forall args . Fullfilled "_image_normalize(ndarray)" args =>
-                   ArgsHMap "_image_normalize(ndarray)" args -> IO [NDArrayHandle]
-_image_normalize args
-  = let scalarArgs
-          = catMaybes
-              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),
-               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_normalize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_normalize_upd ::
-                     forall args . Fullfilled "_image_normalize(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_image_normalize(ndarray)" args -> IO ()
-_image_normalize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),
-               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_normalize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_flip_left_right(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_flip_left_right ::
-                       forall args . Fullfilled "_image_flip_left_right(ndarray)" args =>
-                         ArgsHMap "_image_flip_left_right(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_flip_left_right args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_left_right"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_flip_left_right_upd ::
-                           forall args . Fullfilled "_image_flip_left_right(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_flip_left_right(ndarray)" args -> IO ()
-_image_flip_left_right_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_left_right"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_image_random_flip_left_right(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_random_flip_left_right ::
-                              forall args .
-                                Fullfilled "_image_random_flip_left_right(ndarray)" args =>
-                                ArgsHMap "_image_random_flip_left_right(ndarray)" args ->
-                                  IO [NDArrayHandle]
-_image_random_flip_left_right args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_left_right"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_flip_left_right_upd ::
-                                  forall args .
-                                    Fullfilled "_image_random_flip_left_right(ndarray)" args =>
-                                    [NDArrayHandle] ->
-                                      ArgsHMap "_image_random_flip_left_right(ndarray)" args ->
-                                        IO ()
-_image_random_flip_left_right_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_left_right"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_flip_top_bottom(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_flip_top_bottom ::
-                       forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args =>
-                         ArgsHMap "_image_flip_top_bottom(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_flip_top_bottom args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_top_bottom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_flip_top_bottom_upd ::
-                           forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_flip_top_bottom(ndarray)" args -> IO ()
-_image_flip_top_bottom_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_top_bottom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_image_random_flip_top_bottom(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_random_flip_top_bottom ::
-                              forall args .
-                                Fullfilled "_image_random_flip_top_bottom(ndarray)" args =>
-                                ArgsHMap "_image_random_flip_top_bottom(ndarray)" args ->
-                                  IO [NDArrayHandle]
-_image_random_flip_top_bottom args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_top_bottom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_flip_top_bottom_upd ::
-                                  forall args .
-                                    Fullfilled "_image_random_flip_top_bottom(ndarray)" args =>
-                                    [NDArrayHandle] ->
-                                      ArgsHMap "_image_random_flip_top_bottom(ndarray)" args ->
-                                        IO ()
-_image_random_flip_top_bottom_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_top_bottom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_brightness(ndarray)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_brightness ::
-                         forall args .
-                           Fullfilled "_image_random_brightness(ndarray)" args =>
-                           ArgsHMap "_image_random_brightness(ndarray)" args ->
-                             IO [NDArrayHandle]
-_image_random_brightness args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_brightness"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_brightness_upd ::
-                             forall args .
-                               Fullfilled "_image_random_brightness(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_image_random_brightness(ndarray)" args -> IO ()
-_image_random_brightness_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_brightness"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_contrast(ndarray)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_contrast ::
-                       forall args . Fullfilled "_image_random_contrast(ndarray)" args =>
-                         ArgsHMap "_image_random_contrast(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_random_contrast args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_contrast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_contrast_upd ::
-                           forall args . Fullfilled "_image_random_contrast(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_random_contrast(ndarray)" args -> IO ()
-_image_random_contrast_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_contrast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_saturation(ndarray)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_saturation ::
-                         forall args .
-                           Fullfilled "_image_random_saturation(ndarray)" args =>
-                           ArgsHMap "_image_random_saturation(ndarray)" args ->
-                             IO [NDArrayHandle]
-_image_random_saturation args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_saturation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_saturation_upd ::
-                             forall args .
-                               Fullfilled "_image_random_saturation(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_image_random_saturation(ndarray)" args -> IO ()
-_image_random_saturation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_saturation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_hue(ndarray)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_hue ::
-                  forall args . Fullfilled "_image_random_hue(ndarray)" args =>
-                    ArgsHMap "_image_random_hue(ndarray)" args -> IO [NDArrayHandle]
-_image_random_hue args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_hue"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_hue_upd ::
-                      forall args . Fullfilled "_image_random_hue(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_image_random_hue(ndarray)" args -> IO ()
-_image_random_hue_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_hue"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_color_jitter(ndarray)" =
-     '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float),
-        '("saturation", AttrReq Float), '("hue", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_color_jitter ::
-                           forall args .
-                             Fullfilled "_image_random_color_jitter(ndarray)" args =>
-                             ArgsHMap "_image_random_color_jitter(ndarray)" args ->
-                               IO [NDArrayHandle]
-_image_random_color_jitter args
-  = let scalarArgs
-          = catMaybes
-              [("brightness",) . showValue <$>
-                 (args !? #brightness :: Maybe Float),
-               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
-               ("saturation",) . showValue <$>
-                 (args !? #saturation :: Maybe Float),
-               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_color_jitter"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_color_jitter_upd ::
-                               forall args .
-                                 Fullfilled "_image_random_color_jitter(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_image_random_color_jitter(ndarray)" args -> IO ()
-_image_random_color_jitter_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("brightness",) . showValue <$>
-                 (args !? #brightness :: Maybe Float),
-               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
-               ("saturation",) . showValue <$>
-                 (args !? #saturation :: Maybe Float),
-               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_color_jitter"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_adjust_lighting(ndarray)" =
-     '[ '("alpha", AttrReq [Float]), '("data", AttrOpt NDArrayHandle)]
-
-_image_adjust_lighting ::
-                       forall args . Fullfilled "_image_adjust_lighting(ndarray)" args =>
-                         ArgsHMap "_image_adjust_lighting(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_adjust_lighting args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_adjust_lighting"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_adjust_lighting_upd ::
-                           forall args . Fullfilled "_image_adjust_lighting(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_adjust_lighting(ndarray)" args -> IO ()
-_image_adjust_lighting_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_adjust_lighting"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_lighting(ndarray)" =
-     '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_image_random_lighting ::
-                       forall args . Fullfilled "_image_random_lighting(ndarray)" args =>
-                         ArgsHMap "_image_random_lighting(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_random_lighting args
-  = let scalarArgs
-          = catMaybes
-              [("alpha_std",) . showValue <$>
-                 (args !? #alpha_std :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_lighting"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_lighting_upd ::
-                           forall args . Fullfilled "_image_random_lighting(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_random_lighting(ndarray)" args -> IO ()
-_image_random_lighting_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha_std",) . showValue <$>
-                 (args !? #alpha_std :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_lighting"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "softmax(ndarray)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("data", AttrOpt NDArrayHandle)]
-
-softmax ::
-        forall args . Fullfilled "softmax(ndarray)" args =>
-          ArgsHMap "softmax(ndarray)" args -> IO [NDArrayHandle]
-softmax args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-softmax_upd ::
-            forall args . Fullfilled "softmax(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "softmax(ndarray)" args -> IO ()
-softmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_softmax(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_softmax ::
-                  forall args . Fullfilled "_backward_softmax(ndarray)" args =>
-                    ArgsHMap "_backward_softmax(ndarray)" args -> IO [NDArrayHandle]
-_backward_softmax args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_softmax_upd ::
-                      forall args . Fullfilled "_backward_softmax(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_softmax(ndarray)" args -> IO ()
-_backward_softmax_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log_softmax(ndarray)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("data", AttrOpt NDArrayHandle)]
-
-log_softmax ::
-            forall args . Fullfilled "log_softmax(ndarray)" args =>
-              ArgsHMap "log_softmax(ndarray)" args -> IO [NDArrayHandle]
-log_softmax args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log_softmax_upd ::
-                forall args . Fullfilled "log_softmax(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "log_softmax(ndarray)" args -> IO ()
-log_softmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log_softmax(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log_softmax ::
-                      forall args . Fullfilled "_backward_log_softmax(ndarray)" args =>
-                        ArgsHMap "_backward_log_softmax(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_log_softmax args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log_softmax_upd ::
-                          forall args . Fullfilled "_backward_log_softmax(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_log_softmax(ndarray)" args -> IO ()
-_backward_log_softmax_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Pooling(ndarray)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),
-        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
-        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("p_value", AttrOpt (Maybe Int)),
-        '("count_include_pad", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Pooling ::
-         forall args . Fullfilled "_Pooling(ndarray)" args =>
-           ArgsHMap "_Pooling(ndarray)" args -> IO [NDArrayHandle]
-_Pooling args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Pooling_upd ::
-             forall args . Fullfilled "_Pooling(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Pooling(ndarray)" args -> IO ()
-_Pooling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Pooling(ndarray)" = '[]
-
-_backward_Pooling ::
-                  forall args . Fullfilled "_backward_Pooling(ndarray)" args =>
-                    ArgsHMap "_backward_Pooling(ndarray)" args -> IO [NDArrayHandle]
-_backward_Pooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Pooling_upd ::
-                      forall args . Fullfilled "_backward_Pooling(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_Pooling(ndarray)" args -> IO ()
-_backward_Pooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Deconvolution(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_Deconvolution ::
-               forall args . Fullfilled "_Deconvolution(ndarray)" args =>
-                 ArgsHMap "_Deconvolution(ndarray)" args -> IO [NDArrayHandle]
-_Deconvolution args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Deconvolution_upd ::
-                   forall args . Fullfilled "_Deconvolution(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_Deconvolution(ndarray)" args -> IO ()
-_Deconvolution_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Deconvolution(ndarray)" =
-     '[]
-
-_backward_Deconvolution ::
-                        forall args . Fullfilled "_backward_Deconvolution(ndarray)" args =>
-                          ArgsHMap "_backward_Deconvolution(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_Deconvolution args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Deconvolution_upd ::
-                            forall args . Fullfilled "_backward_Deconvolution(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_Deconvolution(ndarray)" args -> IO ()
-_backward_Deconvolution_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Activation(ndarray)" =
-     '[ '("act_type",
-          AttrReq
-            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Activation ::
-            forall args . Fullfilled "_Activation(ndarray)" args =>
-              ArgsHMap "_Activation(ndarray)" args -> IO [NDArrayHandle]
-_Activation args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Activation_upd ::
-                forall args . Fullfilled "_Activation(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_Activation(ndarray)" args -> IO ()
-_Activation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Activation(ndarray)" = '[]
-
-_backward_Activation ::
-                     forall args . Fullfilled "_backward_Activation(ndarray)" args =>
-                       ArgsHMap "_backward_Activation(ndarray)" args -> IO [NDArrayHandle]
-_backward_Activation args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Activation_upd ::
-                         forall args . Fullfilled "_backward_Activation(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_Activation(ndarray)" args -> IO ()
-_backward_Activation_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_UpSampling(ndarray)" =
-     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),
-        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),
-        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),
-        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_UpSampling ::
-            forall args . Fullfilled "_UpSampling(ndarray)" args =>
-              ArgsHMap "_UpSampling(ndarray)" args -> IO [NDArrayHandle]
-_UpSampling args
-  = let scalarArgs
-          = catMaybes
-              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("sample_type",) . showValue <$>
-                 (args !? #sample_type ::
-                    Maybe (EnumType '["bilinear", "nearest"])),
-               ("multi_input_mode",) . showValue <$>
-                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "UpSampling"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_UpSampling_upd ::
-                forall args . Fullfilled "_UpSampling(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_UpSampling(ndarray)" args -> IO ()
-_UpSampling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("sample_type",) . showValue <$>
-                 (args !? #sample_type ::
-                    Maybe (EnumType '["bilinear", "nearest"])),
-               ("multi_input_mode",) . showValue <$>
-                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "UpSampling"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_UpSampling(ndarray)" = '[]
-
-_backward_UpSampling ::
-                     forall args . Fullfilled "_backward_UpSampling(ndarray)" args =>
-                       ArgsHMap "_backward_UpSampling(ndarray)" args -> IO [NDArrayHandle]
-_backward_UpSampling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_UpSampling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_UpSampling_upd ::
-                         forall args . Fullfilled "_backward_UpSampling(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_UpSampling(ndarray)" args -> IO ()
-_backward_UpSampling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_UpSampling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BatchNorm(ndarray)" =
-     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle),
-        '("moving_mean", AttrOpt NDArrayHandle),
-        '("moving_var", AttrOpt NDArrayHandle)]
-
-_BatchNorm ::
-           forall args . Fullfilled "_BatchNorm(ndarray)" args =>
-             ArgsHMap "_BatchNorm(ndarray)" args -> IO [NDArrayHandle]
-_BatchNorm args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BatchNorm_upd ::
-               forall args . Fullfilled "_BatchNorm(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_BatchNorm(ndarray)" args -> IO ()
-_BatchNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_BatchNorm(ndarray)" = '[]
-
-_backward_BatchNorm ::
-                    forall args . Fullfilled "_backward_BatchNorm(ndarray)" args =>
-                      ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO [NDArrayHandle]
-_backward_BatchNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_BatchNorm_upd ::
-                        forall args . Fullfilled "_backward_BatchNorm(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO ()
-_backward_BatchNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_FullyConnected(ndarray)" =
-     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
-        '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_FullyConnected ::
-                forall args . Fullfilled "_FullyConnected(ndarray)" args =>
-                  ArgsHMap "_FullyConnected(ndarray)" args -> IO [NDArrayHandle]
-_FullyConnected args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_FullyConnected_upd ::
-                    forall args . Fullfilled "_FullyConnected(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_FullyConnected(ndarray)" args -> IO ()
-_FullyConnected_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_FullyConnected(ndarray)" =
-     '[]
-
-_backward_FullyConnected ::
-                         forall args .
-                           Fullfilled "_backward_FullyConnected(ndarray)" args =>
-                           ArgsHMap "_backward_FullyConnected(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_FullyConnected args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_FullyConnected_upd ::
-                             forall args .
-                               Fullfilled "_backward_FullyConnected(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_FullyConnected(ndarray)" args -> IO ()
-_backward_FullyConnected_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Convolution(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_Convolution ::
-             forall args . Fullfilled "_Convolution(ndarray)" args =>
-               ArgsHMap "_Convolution(ndarray)" args -> IO [NDArrayHandle]
-_Convolution args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Convolution_upd ::
-                 forall args . Fullfilled "_Convolution(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_Convolution(ndarray)" args -> IO ()
-_Convolution_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Convolution(ndarray)" = '[]
-
-_backward_Convolution ::
-                      forall args . Fullfilled "_backward_Convolution(ndarray)" args =>
-                        ArgsHMap "_backward_Convolution(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_Convolution args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Convolution_upd ::
-                          forall args . Fullfilled "_backward_Convolution(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_Convolution(ndarray)" args -> IO ()
-_backward_Convolution_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LayerNorm(ndarray)" =
-     '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float),
-        '("output_mean_var", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_LayerNorm ::
-           forall args . Fullfilled "_LayerNorm(ndarray)" args =>
-             ArgsHMap "_LayerNorm(ndarray)" args -> IO [NDArrayHandle]
-_LayerNorm args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LayerNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LayerNorm_upd ::
-               forall args . Fullfilled "_LayerNorm(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_LayerNorm(ndarray)" args -> IO ()
-_LayerNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LayerNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_LayerNorm(ndarray)" = '[]
-
-_backward_LayerNorm ::
-                    forall args . Fullfilled "_backward_LayerNorm(ndarray)" args =>
-                      ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO [NDArrayHandle]
-_backward_LayerNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LayerNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_LayerNorm_upd ::
-                        forall args . Fullfilled "_backward_LayerNorm(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO ()
-_backward_LayerNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LayerNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Concat(ndarray)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_Concat ::
-        forall args . Fullfilled "_Concat(ndarray)" args =>
-          ArgsHMap "_Concat(ndarray)" args -> IO [NDArrayHandle]
-_Concat args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_Concat_upd ::
-            forall args . Fullfilled "_Concat(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_Concat(ndarray)" args -> IO ()
-_Concat_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Concat(ndarray)" = '[]
-
-_backward_Concat ::
-                 forall args . Fullfilled "_backward_Concat(ndarray)" args =>
-                   ArgsHMap "_backward_Concat(ndarray)" args -> IO [NDArrayHandle]
-_backward_Concat args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Concat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Concat_upd ::
-                     forall args . Fullfilled "_backward_Concat(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_Concat(ndarray)" args -> IO ()
-_backward_Concat_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Concat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rnn_param_concat(ndarray)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_rnn_param_concat ::
-                  forall args . Fullfilled "_rnn_param_concat(ndarray)" args =>
-                    ArgsHMap "_rnn_param_concat(ndarray)" args -> IO [NDArrayHandle]
-_rnn_param_concat args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_rnn_param_concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_rnn_param_concat_upd ::
-                      forall args . Fullfilled "_rnn_param_concat(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_rnn_param_concat(ndarray)" args -> IO ()
-_rnn_param_concat_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_rnn_param_concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SoftmaxActivation(ndarray)" =
-     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_SoftmaxActivation ::
-                   forall args . Fullfilled "_SoftmaxActivation(ndarray)" args =>
-                     ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO [NDArrayHandle]
-_SoftmaxActivation args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SoftmaxActivation_upd ::
-                       forall args . Fullfilled "_SoftmaxActivation(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO ()
-_SoftmaxActivation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SoftmaxActivation(ndarray)"
-     = '[]
-
-_backward_SoftmaxActivation ::
-                            forall args .
-                              Fullfilled "_backward_SoftmaxActivation(ndarray)" args =>
-                              ArgsHMap "_backward_SoftmaxActivation(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_SoftmaxActivation args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SoftmaxActivation_upd ::
-                                forall args .
-                                  Fullfilled "_backward_SoftmaxActivation(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> IO ()
-_backward_SoftmaxActivation_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LRN(ndarray)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_LRN ::
-     forall args . Fullfilled "_LRN(ndarray)" args =>
-       ArgsHMap "_LRN(ndarray)" args -> IO [NDArrayHandle]
-_LRN args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),
-               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LRN_upd ::
-         forall args . Fullfilled "_LRN(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_LRN(ndarray)" args -> IO ()
-_LRN_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),
-               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_LRN(ndarray)" = '[]
-
-_backward_LRN ::
-              forall args . Fullfilled "_backward_LRN(ndarray)" args =>
-                ArgsHMap "_backward_LRN(ndarray)" args -> IO [NDArrayHandle]
-_backward_LRN args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_LRN_upd ::
-                  forall args . Fullfilled "_backward_LRN(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_LRN(ndarray)" args -> IO ()
-_backward_LRN_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Dropout(ndarray)" =
-     '[ '("p", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["always", "training"])),
-        '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-_Dropout ::
-         forall args . Fullfilled "_Dropout(ndarray)" args =>
-           ArgsHMap "_Dropout(ndarray)" args -> IO [NDArrayHandle]
-_Dropout args
-  = let scalarArgs
-          = catMaybes
-              [("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["always", "training"])),
-               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Dropout_upd ::
-             forall args . Fullfilled "_Dropout(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Dropout(ndarray)" args -> IO ()
-_Dropout_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["always", "training"])),
-               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Dropout(ndarray)" = '[]
-
-_backward_Dropout ::
-                  forall args . Fullfilled "_backward_Dropout(ndarray)" args =>
-                    ArgsHMap "_backward_Dropout(ndarray)" args -> IO [NDArrayHandle]
-_backward_Dropout args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Dropout_upd ::
-                      forall args . Fullfilled "_backward_Dropout(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_Dropout(ndarray)" args -> IO ()
-_backward_Dropout_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_dequantize(ndarray)" =
-     '[ '("out_type", AttrOpt (EnumType '["float32"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("min_range", AttrOpt NDArrayHandle),
-        '("max_range", AttrOpt NDArrayHandle)]
-
-_contrib_dequantize ::
-                    forall args . Fullfilled "_contrib_dequantize(ndarray)" args =>
-                      ArgsHMap "_contrib_dequantize(ndarray)" args -> IO [NDArrayHandle]
-_contrib_dequantize args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["float32"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dequantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_dequantize_upd ::
-                        forall args . Fullfilled "_contrib_dequantize(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_contrib_dequantize(ndarray)" args -> IO ()
-_contrib_dequantize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["float32"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dequantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantized_flatten(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("min_data", AttrOpt NDArrayHandle),
-        '("max_data", AttrOpt NDArrayHandle)]
-
-_contrib_quantized_flatten ::
-                           forall args .
-                             Fullfilled "_contrib_quantized_flatten(ndarray)" args =>
-                             ArgsHMap "_contrib_quantized_flatten(ndarray)" args ->
-                               IO [NDArrayHandle]
-_contrib_quantized_flatten args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_flatten"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantized_flatten_upd ::
-                               forall args .
-                                 Fullfilled "_contrib_quantized_flatten(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_contrib_quantized_flatten(ndarray)" args -> IO ()
-_contrib_quantized_flatten_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_flatten"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantized_conv(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle),
-        '("min_data", AttrOpt NDArrayHandle),
-        '("max_data", AttrOpt NDArrayHandle),
-        '("min_weight", AttrOpt NDArrayHandle),
-        '("max_weight", AttrOpt NDArrayHandle),
-        '("min_bias", AttrOpt NDArrayHandle),
-        '("max_bias", AttrOpt NDArrayHandle)]
-
-_contrib_quantized_conv ::
-                        forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args =>
-                          ArgsHMap "_contrib_quantized_conv(ndarray)" args ->
-                            IO [NDArrayHandle]
-_contrib_quantized_conv args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_conv"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantized_conv_upd ::
-                            forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_contrib_quantized_conv(ndarray)" args -> IO ()
-_contrib_quantized_conv_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_conv"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_contrib_quantized_fully_connected(ndarray)" =
-     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
-        '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle),
-        '("min_data", AttrOpt NDArrayHandle),
-        '("max_data", AttrOpt NDArrayHandle),
-        '("min_weight", AttrOpt NDArrayHandle),
-        '("max_weight", AttrOpt NDArrayHandle),
-        '("min_bias", AttrOpt NDArrayHandle),
-        '("max_bias", AttrOpt NDArrayHandle)]
-
-_contrib_quantized_fully_connected ::
-                                   forall args .
-                                     Fullfilled "_contrib_quantized_fully_connected(ndarray)"
-                                       args =>
-                                     ArgsHMap "_contrib_quantized_fully_connected(ndarray)" args ->
-                                       IO [NDArrayHandle]
-_contrib_quantized_fully_connected args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantized_fully_connected_upd ::
-                                       forall args .
-                                         Fullfilled "_contrib_quantized_fully_connected(ndarray)"
-                                           args =>
-                                         [NDArrayHandle] ->
-                                           ArgsHMap "_contrib_quantized_fully_connected(ndarray)"
-                                             args
-                                             -> IO ()
-_contrib_quantized_fully_connected_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantized_pooling(ndarray)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),
-        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
-        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("p_value", AttrOpt (Maybe Int)),
-        '("count_include_pad", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt NDArrayHandle),
-        '("min_data", AttrOpt NDArrayHandle),
-        '("max_data", AttrOpt NDArrayHandle)]
-
-_contrib_quantized_pooling ::
-                           forall args .
-                             Fullfilled "_contrib_quantized_pooling(ndarray)" args =>
-                             ArgsHMap "_contrib_quantized_pooling(ndarray)" args ->
-                               IO [NDArrayHandle]
-_contrib_quantized_pooling args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantized_pooling_upd ::
-                               forall args .
-                                 Fullfilled "_contrib_quantized_pooling(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_contrib_quantized_pooling(ndarray)" args -> IO ()
-_contrib_quantized_pooling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_requantize(ndarray)" =
-     '[ '("min_calib_range", AttrOpt (Maybe Float)),
-        '("max_calib_range", AttrOpt (Maybe Float)),
-        '("data", AttrOpt NDArrayHandle),
-        '("min_range", AttrOpt NDArrayHandle),
-        '("max_range", AttrOpt NDArrayHandle)]
-
-_contrib_requantize ::
-                    forall args . Fullfilled "_contrib_requantize(ndarray)" args =>
-                      ArgsHMap "_contrib_requantize(ndarray)" args -> IO [NDArrayHandle]
-_contrib_requantize args
-  = let scalarArgs
-          = catMaybes
-              [("min_calib_range",) . showValue <$>
-                 (args !? #min_calib_range :: Maybe (Maybe Float)),
-               ("max_calib_range",) . showValue <$>
-                 (args !? #max_calib_range :: Maybe (Maybe Float))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_requantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_requantize_upd ::
-                        forall args . Fullfilled "_contrib_requantize(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_contrib_requantize(ndarray)" args -> IO ()
-_contrib_requantize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("min_calib_range",) . showValue <$>
-                 (args !? #min_calib_range :: Maybe (Maybe Float)),
-               ("max_calib_range",) . showValue <$>
-                 (args !? #max_calib_range :: Maybe (Maybe Float))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_requantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantize(ndarray)" =
-     '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("min_range", AttrOpt NDArrayHandle),
-        '("max_range", AttrOpt NDArrayHandle)]
-
-_contrib_quantize ::
-                  forall args . Fullfilled "_contrib_quantize(ndarray)" args =>
-                    ArgsHMap "_contrib_quantize(ndarray)" args -> IO [NDArrayHandle]
-_contrib_quantize args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantize_upd ::
-                      forall args . Fullfilled "_contrib_quantize(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_contrib_quantize(ndarray)" args -> IO ()
-_contrib_quantize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvimdecode(ndarray)" =
-     '[ '("flag", AttrOpt Int), '("to_rgb", AttrOpt Bool),
-        '("buf", AttrOpt NDArrayHandle)]
-
-_cvimdecode ::
-            forall args . Fullfilled "_cvimdecode(ndarray)" args =>
-              ArgsHMap "_cvimdecode(ndarray)" args -> IO [NDArrayHandle]
-_cvimdecode args
-  = let scalarArgs
-          = catMaybes
-              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvimdecode_upd ::
-                forall args . Fullfilled "_cvimdecode(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_cvimdecode(ndarray)" args -> IO ()
-_cvimdecode_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvimread(ndarray)" =
-     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),
-        '("to_rgb", AttrOpt Bool)]
-
-_cvimread ::
-          forall args . Fullfilled "_cvimread(ndarray)" args =>
-            ArgsHMap "_cvimread(ndarray)" args -> IO [NDArrayHandle]
-_cvimread args
-  = let scalarArgs
-          = catMaybes
-              [("filename",) . showValue <$> (args !? #filename :: Maybe String),
-               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimread"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvimread_upd ::
-              forall args . Fullfilled "_cvimread(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_cvimread(ndarray)" args -> IO ()
-_cvimread_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("filename",) . showValue <$> (args !? #filename :: Maybe String),
-               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimread"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvimresize(ndarray)" =
-     '[ '("w", AttrReq Int), '("h", AttrReq Int),
-        '("interp", AttrOpt Int), '("src", AttrOpt NDArrayHandle)]
-
-_cvimresize ::
-            forall args . Fullfilled "_cvimresize(ndarray)" args =>
-              ArgsHMap "_cvimresize(ndarray)" args -> IO [NDArrayHandle]
-_cvimresize args
-  = let scalarArgs
-          = catMaybes
-              [("w",) . showValue <$> (args !? #w :: Maybe Int),
-               ("h",) . showValue <$> (args !? #h :: Maybe Int),
-               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimresize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvimresize_upd ::
-                forall args . Fullfilled "_cvimresize(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_cvimresize(ndarray)" args -> IO ()
-_cvimresize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("w",) . showValue <$> (args !? #w :: Maybe Int),
-               ("h",) . showValue <$> (args !? #h :: Maybe Int),
-               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimresize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvcopyMakeBorder(ndarray)" =
-     '[ '("top", AttrReq Int), '("bot", AttrReq Int),
-        '("left", AttrReq Int), '("right", AttrReq Int),
-        '("type", AttrOpt Int), '("value", AttrOpt Double),
-        '("values", AttrOpt [Double]), '("src", AttrOpt NDArrayHandle)]
-
-_cvcopyMakeBorder ::
-                  forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args =>
-                    ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO [NDArrayHandle]
-_cvcopyMakeBorder args
-  = let scalarArgs
-          = catMaybes
-              [("top",) . showValue <$> (args !? #top :: Maybe Int),
-               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),
-               ("left",) . showValue <$> (args !? #left :: Maybe Int),
-               ("right",) . showValue <$> (args !? #right :: Maybe Int),
-               ("type",) . showValue <$> (args !? #type :: Maybe Int),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double),
-               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvcopyMakeBorder"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvcopyMakeBorder_upd ::
-                      forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO ()
-_cvcopyMakeBorder_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("top",) . showValue <$> (args !? #top :: Maybe Int),
-               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),
-               ("left",) . showValue <$> (args !? #left :: Maybe Int),
-               ("right",) . showValue <$> (args !? #right :: Maybe Int),
-               ("type",) . showValue <$> (args !? #type :: Maybe Int),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double),
-               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvcopyMakeBorder"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_NoGradient(ndarray)" = '[]
-
-_NoGradient ::
-            forall args . Fullfilled "_NoGradient(ndarray)" args =>
-              ArgsHMap "_NoGradient(ndarray)" args -> IO [NDArrayHandle]
-_NoGradient args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_NoGradient"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_NoGradient_upd ::
-                forall args . Fullfilled "_NoGradient(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_NoGradient(ndarray)" args -> IO ()
-_NoGradient_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_NoGradient"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CachedOp(ndarray)" = '[]
-
-_CachedOp ::
-          forall args . Fullfilled "_CachedOp(ndarray)" args =>
-            ArgsHMap "_CachedOp(ndarray)" args -> IO [NDArrayHandle]
-_CachedOp args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CachedOp_upd ::
-              forall args . Fullfilled "_CachedOp(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_CachedOp(ndarray)" args -> IO ()
-_CachedOp_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_CachedOp(ndarray)" = '[]
-
-_backward_CachedOp ::
-                   forall args . Fullfilled "_backward_CachedOp(ndarray)" args =>
-                     ArgsHMap "_backward_CachedOp(ndarray)" args -> IO [NDArrayHandle]
-_backward_CachedOp args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_CachedOp_upd ::
-                       forall args . Fullfilled "_backward_CachedOp(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_CachedOp(ndarray)" args -> IO ()
-_backward_CachedOp_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_copyto(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_copyto ::
-        forall args . Fullfilled "_copyto(ndarray)" args =>
-          ArgsHMap "_copyto(ndarray)" args -> IO [NDArrayHandle]
-_copyto args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copyto"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_copyto_upd ::
-            forall args . Fullfilled "_copyto(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_copyto(ndarray)" args -> IO ()
-_copyto_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copyto"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "softmax_cross_entropy(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-softmax_cross_entropy ::
-                      forall args . Fullfilled "softmax_cross_entropy(ndarray)" args =>
-                        ArgsHMap "softmax_cross_entropy(ndarray)" args ->
-                          IO [NDArrayHandle]
-softmax_cross_entropy args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-softmax_cross_entropy_upd ::
-                          forall args . Fullfilled "softmax_cross_entropy(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "softmax_cross_entropy(ndarray)" args -> IO ()
-softmax_cross_entropy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_softmax_cross_entropy(ndarray)" = '[]
-
-_backward_softmax_cross_entropy ::
-                                forall args .
-                                  Fullfilled "_backward_softmax_cross_entropy(ndarray)" args =>
-                                  ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args ->
-                                    IO [NDArrayHandle]
-_backward_softmax_cross_entropy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_softmax_cross_entropy_upd ::
-                                    forall args .
-                                      Fullfilled "_backward_softmax_cross_entropy(ndarray)" args =>
-                                      [NDArrayHandle] ->
-                                        ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args ->
-                                          IO ()
-_backward_softmax_cross_entropy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Pad(ndarray)" =
-     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),
-        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Pad ::
-     forall args . Fullfilled "_Pad(ndarray)" args =>
-       ArgsHMap "_Pad(ndarray)" args -> IO [NDArrayHandle]
-_Pad args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["constant", "edge", "reflect"])),
-               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),
-               ("constant_value",) . showValue <$>
-                 (args !? #constant_value :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Pad_upd ::
-         forall args . Fullfilled "_Pad(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_Pad(ndarray)" args -> IO ()
-_Pad_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["constant", "edge", "reflect"])),
-               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),
-               ("constant_value",) . showValue <$>
-                 (args !? #constant_value :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_foreach(ndarray)" = '[]
-
-_backward_foreach ::
-                  forall args . Fullfilled "_backward_foreach(ndarray)" args =>
-                    ArgsHMap "_backward_foreach(ndarray)" args -> IO [NDArrayHandle]
-_backward_foreach args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_foreach"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_foreach_upd ::
-                      forall args . Fullfilled "_backward_foreach(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_foreach(ndarray)" args -> IO ()
-_backward_foreach_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_foreach"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_while_loop(ndarray)" = '[]
-
-_backward_while_loop ::
-                     forall args . Fullfilled "_backward_while_loop(ndarray)" args =>
-                       ArgsHMap "_backward_while_loop(ndarray)" args -> IO [NDArrayHandle]
-_backward_while_loop args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_while_loop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_while_loop_upd ::
-                         forall args . Fullfilled "_backward_while_loop(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_while_loop(ndarray)" args -> IO ()
-_backward_while_loop_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_while_loop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cond(ndarray)" = '[]
-
-_backward_cond ::
-               forall args . Fullfilled "_backward_cond(ndarray)" args =>
-                 ArgsHMap "_backward_cond(ndarray)" args -> IO [NDArrayHandle]
-_backward_cond args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cond"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cond_upd ::
-                   forall args . Fullfilled "_backward_cond(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cond(ndarray)" args -> IO ()
-_backward_cond_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cond"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LeakyReLU(ndarray)" =
-     '[ '("act_type",
-          AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),
-        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),
-        '("upper_bound", AttrOpt Float), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle)]
-
-_LeakyReLU ::
-           forall args . Fullfilled "_LeakyReLU(ndarray)" args =>
-             ArgsHMap "_LeakyReLU(ndarray)" args -> IO [NDArrayHandle]
-_LeakyReLU args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),
-               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),
-               ("lower_bound",) . showValue <$>
-                 (args !? #lower_bound :: Maybe Float),
-               ("upper_bound",) . showValue <$>
-                 (args !? #upper_bound :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LeakyReLU_upd ::
-               forall args . Fullfilled "_LeakyReLU(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_LeakyReLU(ndarray)" args -> IO ()
-_LeakyReLU_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),
-               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),
-               ("lower_bound",) . showValue <$>
-                 (args !? #lower_bound :: Maybe Float),
-               ("upper_bound",) . showValue <$>
-                 (args !? #upper_bound :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SwapAxis(ndarray)" =
-     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_SwapAxis ::
-          forall args . Fullfilled "_SwapAxis(ndarray)" args =>
-            ArgsHMap "_SwapAxis(ndarray)" args -> IO [NDArrayHandle]
-_SwapAxis args
-  = let scalarArgs
-          = catMaybes
-              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),
-               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SwapAxis_upd ::
-              forall args . Fullfilled "_SwapAxis(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_SwapAxis(ndarray)" args -> IO ()
-_SwapAxis_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),
-               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_IdentityAttachKLSparseReg(ndarray)" =
-     '[ '("sparseness_target", AttrOpt Float),
-        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_IdentityAttachKLSparseReg ::
-                           forall args .
-                             Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args =>
-                             ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args ->
-                               IO [NDArrayHandle]
-_IdentityAttachKLSparseReg args
-  = let scalarArgs
-          = catMaybes
-              [("sparseness_target",) . showValue <$>
-                 (args !? #sparseness_target :: Maybe Float),
-               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_IdentityAttachKLSparseReg_upd ::
-                               forall args .
-                                 Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> IO ()
-_IdentityAttachKLSparseReg_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("sparseness_target",) . showValue <$>
-                 (args !? #sparseness_target :: Maybe Float),
-               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SliceChannel(ndarray)" =
-     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),
-        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-_SliceChannel ::
-              forall args . Fullfilled "_SliceChannel(ndarray)" args =>
-                ArgsHMap "_SliceChannel(ndarray)" args -> IO [NDArrayHandle]
-_SliceChannel args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SliceChannel_upd ::
-                  forall args . Fullfilled "_SliceChannel(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_SliceChannel(ndarray)" args -> IO ()
-_SliceChannel_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BatchNorm_v1(ndarray)" =
-     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_BatchNorm_v1 ::
-              forall args . Fullfilled "_BatchNorm_v1(ndarray)" args =>
-                ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO [NDArrayHandle]
-_BatchNorm_v1 args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BatchNorm_v1_upd ::
-                  forall args . Fullfilled "_BatchNorm_v1(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO ()
-_BatchNorm_v1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "signsgd_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle)]
-
-signsgd_update ::
-               forall args . Fullfilled "signsgd_update(ndarray)" args =>
-                 ArgsHMap "signsgd_update(ndarray)" args -> IO [NDArrayHandle]
-signsgd_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signsgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-signsgd_update_upd ::
-                   forall args . Fullfilled "signsgd_update(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "signsgd_update(ndarray)" args -> IO ()
-signsgd_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signsgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "signum_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]
-
-signum_update ::
-              forall args . Fullfilled "signum_update(ndarray)" args =>
-                ArgsHMap "signum_update(ndarray)" args -> IO [NDArrayHandle]
-signum_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signum_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-signum_update_upd ::
-                  forall args . Fullfilled "signum_update(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "signum_update(ndarray)" args -> IO ()
-signum_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signum_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sgd_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle)]
-
-sgd_update ::
-           forall args . Fullfilled "sgd_update(ndarray)" args =>
-             ArgsHMap "sgd_update(ndarray)" args -> IO [NDArrayHandle]
-sgd_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sgd_update_upd ::
-               forall args . Fullfilled "sgd_update(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "sgd_update(ndarray)" args -> IO ()
-sgd_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sgd_mom_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]
-
-sgd_mom_update ::
-               forall args . Fullfilled "sgd_mom_update(ndarray)" args =>
-                 ArgsHMap "sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]
-sgd_mom_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sgd_mom_update_upd ::
-                   forall args . Fullfilled "sgd_mom_update(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "sgd_mom_update(ndarray)" args -> IO ()
-sgd_mom_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "mp_sgd_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle),
-        '("weight32", AttrOpt NDArrayHandle)]
-
-mp_sgd_update ::
-              forall args . Fullfilled "mp_sgd_update(ndarray)" args =>
-                ArgsHMap "mp_sgd_update(ndarray)" args -> IO [NDArrayHandle]
-mp_sgd_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-mp_sgd_update_upd ::
-                  forall args . Fullfilled "mp_sgd_update(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "mp_sgd_update(ndarray)" args -> IO ()
-mp_sgd_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "mp_sgd_mom_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle),
-        '("weight32", AttrOpt NDArrayHandle)]
-
-mp_sgd_mom_update ::
-                  forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args =>
-                    ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]
-mp_sgd_mom_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-mp_sgd_mom_update_upd ::
-                      forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO ()
-mp_sgd_mom_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ftml_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double),
-        '("t", AttrReq Int), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("d", AttrOpt NDArrayHandle),
-        '("v", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle)]
-
-ftml_update ::
-            forall args . Fullfilled "ftml_update(ndarray)" args =>
-              ArgsHMap "ftml_update(ndarray)" args -> IO [NDArrayHandle]
-ftml_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),
-               ("t",) . showValue <$> (args !? #t :: Maybe Int),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("d",) <$> (args !? #d :: Maybe NDArrayHandle),
-               ("v",) <$> (args !? #v :: Maybe NDArrayHandle),
-               ("z",) <$> (args !? #z :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftml_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ftml_update_upd ::
-                forall args . Fullfilled "ftml_update(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "ftml_update(ndarray)" args -> IO ()
-ftml_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),
-               ("t",) . showValue <$> (args !? #t :: Maybe Int),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("d",) <$> (args !? #d :: Maybe NDArrayHandle),
-               ("v",) <$> (args !? #v :: Maybe NDArrayHandle),
-               ("z",) <$> (args !? #z :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftml_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "adam_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle),
-        '("var", AttrOpt NDArrayHandle)]
-
-adam_update ::
-            forall args . Fullfilled "adam_update(ndarray)" args =>
-              ArgsHMap "adam_update(ndarray)" args -> IO [NDArrayHandle]
-adam_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),
-               ("var",) <$> (args !? #var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "adam_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-adam_update_upd ::
-                forall args . Fullfilled "adam_update(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "adam_update(ndarray)" args -> IO ()
-adam_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),
-               ("var",) <$> (args !? #var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "adam_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rmsprop_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle)]
-
-rmsprop_update ::
-               forall args . Fullfilled "rmsprop_update(ndarray)" args =>
-                 ArgsHMap "rmsprop_update(ndarray)" args -> IO [NDArrayHandle]
-rmsprop_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmsprop_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rmsprop_update_upd ::
-                   forall args . Fullfilled "rmsprop_update(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "rmsprop_update(ndarray)" args -> IO ()
-rmsprop_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmsprop_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rmspropalex_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle),
-        '("g", AttrOpt NDArrayHandle), '("delta", AttrOpt NDArrayHandle)]
-
-rmspropalex_update ::
-                   forall args . Fullfilled "rmspropalex_update(ndarray)" args =>
-                     ArgsHMap "rmspropalex_update(ndarray)" args -> IO [NDArrayHandle]
-rmspropalex_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle),
-               ("g",) <$> (args !? #g :: Maybe NDArrayHandle),
-               ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmspropalex_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rmspropalex_update_upd ::
-                       forall args . Fullfilled "rmspropalex_update(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "rmspropalex_update(ndarray)" args -> IO ()
-rmspropalex_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle),
-               ("g",) <$> (args !? #g :: Maybe NDArrayHandle),
-               ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmspropalex_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ftrl_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),
-        '("beta", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle),
-        '("n", AttrOpt NDArrayHandle)]
-
-ftrl_update ::
-            forall args . Fullfilled "ftrl_update(ndarray)" args =>
-              ArgsHMap "ftrl_update(ndarray)" args -> IO [NDArrayHandle]
-ftrl_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("z",) <$> (args !? #z :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftrl_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ftrl_update_upd ::
-                forall args . Fullfilled "ftrl_update(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "ftrl_update(ndarray)" args -> IO ()
-ftrl_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("z",) <$> (args !? #z :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftrl_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sparse_adagrad_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle),
-        '("history", AttrOpt NDArrayHandle)]
-
-_sparse_adagrad_update ::
-                       forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args =>
-                         ArgsHMap "_sparse_adagrad_update(ndarray)" args ->
-                           IO [NDArrayHandle]
-_sparse_adagrad_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_adagrad_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sparse_adagrad_update_upd ::
-                           forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_sparse_adagrad_update(ndarray)" args -> IO ()
-_sparse_adagrad_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_adagrad_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LinearRegressionOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_LinearRegressionOutput ::
-                        forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args =>
-                          ArgsHMap "_LinearRegressionOutput(ndarray)" args ->
-                            IO [NDArrayHandle]
-_LinearRegressionOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LinearRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LinearRegressionOutput_upd ::
-                            forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_LinearRegressionOutput(ndarray)" args -> IO ()
-_LinearRegressionOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LinearRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linear_reg_out(ndarray)" =
-     '[]
-
-_backward_linear_reg_out ::
-                         forall args .
-                           Fullfilled "_backward_linear_reg_out(ndarray)" args =>
-                           ArgsHMap "_backward_linear_reg_out(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_linear_reg_out args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linear_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linear_reg_out_upd ::
-                             forall args .
-                               Fullfilled "_backward_linear_reg_out(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_linear_reg_out(ndarray)" args -> IO ()
-_backward_linear_reg_out_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linear_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_MAERegressionOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_MAERegressionOutput ::
-                     forall args . Fullfilled "_MAERegressionOutput(ndarray)" args =>
-                       ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO [NDArrayHandle]
-_MAERegressionOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MAERegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_MAERegressionOutput_upd ::
-                         forall args . Fullfilled "_MAERegressionOutput(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO ()
-_MAERegressionOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MAERegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mae_reg_out(ndarray)" = '[]
-
-_backward_mae_reg_out ::
-                      forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args =>
-                        ArgsHMap "_backward_mae_reg_out(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_mae_reg_out args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mae_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mae_reg_out_upd ::
-                          forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_mae_reg_out(ndarray)" args -> IO ()
-_backward_mae_reg_out_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mae_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LogisticRegressionOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_LogisticRegressionOutput ::
-                          forall args .
-                            Fullfilled "_LogisticRegressionOutput(ndarray)" args =>
-                            ArgsHMap "_LogisticRegressionOutput(ndarray)" args ->
-                              IO [NDArrayHandle]
-_LogisticRegressionOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LogisticRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LogisticRegressionOutput_upd ::
-                              forall args .
-                                Fullfilled "_LogisticRegressionOutput(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> IO ()
-_LogisticRegressionOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LogisticRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_logistic_reg_out(ndarray)" =
-     '[]
-
-_backward_logistic_reg_out ::
-                           forall args .
-                             Fullfilled "_backward_logistic_reg_out(ndarray)" args =>
-                             ArgsHMap "_backward_logistic_reg_out(ndarray)" args ->
-                               IO [NDArrayHandle]
-_backward_logistic_reg_out args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_logistic_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_logistic_reg_out_upd ::
-                               forall args .
-                                 Fullfilled "_backward_logistic_reg_out(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_backward_logistic_reg_out(ndarray)" args -> IO ()
-_backward_logistic_reg_out_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_logistic_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CustomFunction(ndarray)" = '[]
-
-_CustomFunction ::
-                forall args . Fullfilled "_CustomFunction(ndarray)" args =>
-                  ArgsHMap "_CustomFunction(ndarray)" args -> IO [NDArrayHandle]
-_CustomFunction args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CustomFunction_upd ::
-                    forall args . Fullfilled "_CustomFunction(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_CustomFunction(ndarray)" args -> IO ()
-_CustomFunction_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_CustomFunction(ndarray)" =
-     '[]
-
-_backward_CustomFunction ::
-                         forall args .
-                           Fullfilled "_backward_CustomFunction(ndarray)" args =>
-                           ArgsHMap "_backward_CustomFunction(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_CustomFunction args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_CustomFunction_upd ::
-                             forall args .
-                               Fullfilled "_backward_CustomFunction(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_CustomFunction(ndarray)" args -> IO ()
-_backward_CustomFunction_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__Native(ndarray)" = '[]
-
-_backward__Native ::
-                  forall args . Fullfilled "_backward__Native(ndarray)" args =>
-                    ArgsHMap "_backward__Native(ndarray)" args -> IO [NDArrayHandle]
-_backward__Native args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__Native"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__Native_upd ::
-                      forall args . Fullfilled "_backward__Native(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward__Native(ndarray)" args -> IO ()
-_backward__Native_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__Native"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__NDArray(ndarray)" = '[]
-
-_backward__NDArray ::
-                   forall args . Fullfilled "_backward__NDArray(ndarray)" args =>
-                     ArgsHMap "_backward__NDArray(ndarray)" args -> IO [NDArrayHandle]
-_backward__NDArray args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__NDArray"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__NDArray_upd ::
-                       forall args . Fullfilled "_backward__NDArray(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward__NDArray(ndarray)" args -> IO ()
-_backward__NDArray_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__NDArray"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiBoxTarget(ndarray)" =
-     '[ '("overlap_threshold", AttrOpt Float),
-        '("ignore_label", AttrOpt Float),
-        '("negative_mining_ratio", AttrOpt Float),
-        '("negative_mining_thresh", AttrOpt Float),
-        '("minimum_negative_samples", AttrOpt Int),
-        '("variances", AttrOpt [Float]),
-        '("anchor", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle),
-        '("cls_pred", AttrOpt NDArrayHandle)]
-
-_contrib_MultiBoxTarget ::
-                        forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args =>
-                          ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args ->
-                            IO [NDArrayHandle]
-_contrib_MultiBoxTarget args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_threshold",) . showValue <$>
-                 (args !? #overlap_threshold :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("negative_mining_ratio",) . showValue <$>
-                 (args !? #negative_mining_ratio :: Maybe Float),
-               ("negative_mining_thresh",) . showValue <$>
-                 (args !? #negative_mining_thresh :: Maybe Float),
-               ("minimum_negative_samples",) . showValue <$>
-                 (args !? #minimum_negative_samples :: Maybe Int),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float])]
-        tensorArgs
-          = catMaybes
-              [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiBoxTarget_upd ::
-                            forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> IO ()
-_contrib_MultiBoxTarget_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_threshold",) . showValue <$>
-                 (args !? #overlap_threshold :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("negative_mining_ratio",) . showValue <$>
-                 (args !? #negative_mining_ratio :: Maybe Float),
-               ("negative_mining_thresh",) . showValue <$>
-                 (args !? #negative_mining_thresh :: Maybe Float),
-               ("minimum_negative_samples",) . showValue <$>
-                 (args !? #minimum_negative_samples :: Maybe Int),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float])]
-        tensorArgs
-          = catMaybes
-              [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxTarget(ndarray)" = '[]
-
-_backward__contrib_MultiBoxTarget ::
-                                  forall args .
-                                    Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" args =>
-                                    ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args ->
-                                      IO [NDArrayHandle]
-_backward__contrib_MultiBoxTarget args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiBoxTarget_upd ::
-                                      forall args .
-                                        Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)"
-                                          args =>
-                                        [NDArrayHandle] ->
-                                          ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args
-                                            -> IO ()
-_backward__contrib_MultiBoxTarget_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_Proposal(ndarray)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle),
-        '("bbox_pred", AttrOpt NDArrayHandle),
-        '("im_info", AttrOpt NDArrayHandle)]
-
-_contrib_Proposal ::
-                  forall args . Fullfilled "_contrib_Proposal(ndarray)" args =>
-                    ArgsHMap "_contrib_Proposal(ndarray)" args -> IO [NDArrayHandle]
-_contrib_Proposal args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_Proposal_upd ::
-                      forall args . Fullfilled "_contrib_Proposal(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_contrib_Proposal(ndarray)" args -> IO ()
-_contrib_Proposal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__contrib_Proposal(ndarray)"
-     = '[]
-
-_backward__contrib_Proposal ::
-                            forall args .
-                              Fullfilled "_backward__contrib_Proposal(ndarray)" args =>
-                              ArgsHMap "_backward__contrib_Proposal(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward__contrib_Proposal args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_Proposal_upd ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_Proposal(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> IO ()
-_backward__contrib_Proposal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_count_sketch(ndarray)" =
-     '[ '("out_dim", AttrReq Int),
-        '("processing_batch_size", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle), '("h", AttrOpt NDArrayHandle),
-        '("s", AttrOpt NDArrayHandle)]
-
-_contrib_count_sketch ::
-                      forall args . Fullfilled "_contrib_count_sketch(ndarray)" args =>
-                        ArgsHMap "_contrib_count_sketch(ndarray)" args ->
-                          IO [NDArrayHandle]
-_contrib_count_sketch args
-  = let scalarArgs
-          = catMaybes
-              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),
-               ("processing_batch_size",) . showValue <$>
-                 (args !? #processing_batch_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("h",) <$> (args !? #h :: Maybe NDArrayHandle),
-               ("s",) <$> (args !? #s :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_count_sketch_upd ::
-                          forall args . Fullfilled "_contrib_count_sketch(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_contrib_count_sketch(ndarray)" args -> IO ()
-_contrib_count_sketch_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),
-               ("processing_batch_size",) . showValue <$>
-                 (args !? #processing_batch_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("h",) <$> (args !? #h :: Maybe NDArrayHandle),
-               ("s",) <$> (args !? #s :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_count_sketch(ndarray)" = '[]
-
-_backward__contrib_count_sketch ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_count_sketch(ndarray)" args =>
-                                  ArgsHMap "_backward__contrib_count_sketch(ndarray)" args ->
-                                    IO [NDArrayHandle]
-_backward__contrib_count_sketch args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_count_sketch_upd ::
-                                    forall args .
-                                      Fullfilled "_backward__contrib_count_sketch(ndarray)" args =>
-                                      [NDArrayHandle] ->
-                                        ArgsHMap "_backward__contrib_count_sketch(ndarray)" args ->
-                                          IO ()
-_backward__contrib_count_sketch_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiBoxDetection(ndarray)" =
-     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),
-        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),
-        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),
-        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt NDArrayHandle),
-        '("loc_pred", AttrOpt NDArrayHandle),
-        '("anchor", AttrOpt NDArrayHandle)]
-
-_contrib_MultiBoxDetection ::
-                           forall args .
-                             Fullfilled "_contrib_MultiBoxDetection(ndarray)" args =>
-                             ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args ->
-                               IO [NDArrayHandle]
-_contrib_MultiBoxDetection args
-  = let scalarArgs
-          = catMaybes
-              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("nms_threshold",) . showValue <$>
-                 (args !? #nms_threshold :: Maybe Float),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float]),
-               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle),
-               ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiBoxDetection_upd ::
-                               forall args .
-                                 Fullfilled "_contrib_MultiBoxDetection(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> IO ()
-_contrib_MultiBoxDetection_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("nms_threshold",) . showValue <$>
-                 (args !? #nms_threshold :: Maybe Float),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float]),
-               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle),
-               ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxDetection(ndarray)" = '[]
-
-_backward__contrib_MultiBoxDetection ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiBoxDetection(ndarray)"
-                                         args =>
-                                       ArgsHMap "_backward__contrib_MultiBoxDetection(ndarray)" args
-                                         -> IO [NDArrayHandle]
-_backward__contrib_MultiBoxDetection args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiBoxDetection_upd ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward__contrib_MultiBoxDetection(ndarray)" args =>
-                                           [NDArrayHandle] ->
-                                             ArgsHMap
-                                               "_backward__contrib_MultiBoxDetection(ndarray)"
-                                               args
-                                               -> IO ()
-_backward__contrib_MultiBoxDetection_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_DeformablePSROIPooling(ndarray)"
-     = '[]
-
-_backward__contrib_DeformablePSROIPooling ::
-                                          forall args .
-                                            Fullfilled
-                                              "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                              args =>
-                                            ArgsHMap
-                                              "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                              args
-                                              -> IO [NDArrayHandle]
-_backward__contrib_DeformablePSROIPooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_DeformablePSROIPooling_upd ::
-                                              forall args .
-                                                Fullfilled
-                                                  "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                                  args =>
-                                                [NDArrayHandle] ->
-                                                  ArgsHMap
-                                                    "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                                    args
-                                                    -> IO ()
-_backward__contrib_DeformablePSROIPooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__contrib_CTCLoss(ndarray)" =
-     '[]
-
-_backward__contrib_CTCLoss ::
-                           forall args .
-                             Fullfilled "_backward__contrib_CTCLoss(ndarray)" args =>
-                             ArgsHMap "_backward__contrib_CTCLoss(ndarray)" args ->
-                               IO [NDArrayHandle]
-_backward__contrib_CTCLoss args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_CTCLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_CTCLoss_upd ::
-                               forall args .
-                                 Fullfilled "_backward__contrib_CTCLoss(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_backward__contrib_CTCLoss(ndarray)" args -> IO ()
-_backward__contrib_CTCLoss_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_CTCLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiProposal(ndarray)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle),
-        '("bbox_pred", AttrOpt NDArrayHandle),
-        '("im_info", AttrOpt NDArrayHandle)]
-
-_contrib_MultiProposal ::
-                       forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args =>
-                         ArgsHMap "_contrib_MultiProposal(ndarray)" args ->
-                           IO [NDArrayHandle]
-_contrib_MultiProposal args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiProposal_upd ::
-                           forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_contrib_MultiProposal(ndarray)" args -> IO ()
-_contrib_MultiProposal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiProposal(ndarray)" = '[]
-
-_backward__contrib_MultiProposal ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiProposal(ndarray)" args =>
-                                   ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args ->
-                                     IO [NDArrayHandle]
-_backward__contrib_MultiProposal args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiProposal_upd ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiProposal(ndarray)"
-                                         args =>
-                                       [NDArrayHandle] ->
-                                         ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args
-                                           -> IO ()
-_backward__contrib_MultiProposal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiBoxPrior(ndarray)" =
-     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),
-        '("offsets", AttrOpt [Float]), '("data", AttrOpt NDArrayHandle)]
-
-_contrib_MultiBoxPrior ::
-                       forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args =>
-                         ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args ->
-                           IO [NDArrayHandle]
-_contrib_MultiBoxPrior args
-  = let scalarArgs
-          = catMaybes
-              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),
-               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiBoxPrior_upd ::
-                           forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> IO ()
-_contrib_MultiBoxPrior_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),
-               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxPrior(ndarray)" = '[]
-
-_backward__contrib_MultiBoxPrior ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" args =>
-                                   ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args ->
-                                     IO [NDArrayHandle]
-_backward__contrib_MultiBoxPrior args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiBoxPrior_upd ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)"
-                                         args =>
-                                       [NDArrayHandle] ->
-                                         ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args
-                                           -> IO ()
-_backward__contrib_MultiBoxPrior_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_fft(ndarray)" =
-     '[ '("compute_size", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_fft ::
-             forall args . Fullfilled "_contrib_fft(ndarray)" args =>
-               ArgsHMap "_contrib_fft(ndarray)" args -> IO [NDArrayHandle]
-_contrib_fft args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_fft_upd ::
-                 forall args . Fullfilled "_contrib_fft(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_contrib_fft(ndarray)" args -> IO ()
-_contrib_fft_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__contrib_fft(ndarray)" = '[]
-
-_backward__contrib_fft ::
-                       forall args . Fullfilled "_backward__contrib_fft(ndarray)" args =>
-                         ArgsHMap "_backward__contrib_fft(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward__contrib_fft args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_fft_upd ::
-                           forall args . Fullfilled "_backward__contrib_fft(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward__contrib_fft(ndarray)" args -> IO ()
-_backward__contrib_fft_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_PSROIPooling(ndarray)" = '[]
-
-_backward__contrib_PSROIPooling ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args =>
-                                  ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args ->
-                                    IO [NDArrayHandle]
-_backward__contrib_PSROIPooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_PSROIPooling_upd ::
-                                    forall args .
-                                      Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args =>
-                                      [NDArrayHandle] ->
-                                        ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args ->
-                                          IO ()
-_backward__contrib_PSROIPooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_contrib_DeformableConvolution(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("num_deformable_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("offset", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_contrib_DeformableConvolution ::
-                               forall args .
-                                 Fullfilled "_contrib_DeformableConvolution(ndarray)" args =>
-                                 ArgsHMap "_contrib_DeformableConvolution(ndarray)" args ->
-                                   IO [NDArrayHandle]
-_contrib_DeformableConvolution args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("num_deformable_group",) . showValue <$>
-                 (args !? #num_deformable_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_DeformableConvolution_upd ::
-                                   forall args .
-                                     Fullfilled "_contrib_DeformableConvolution(ndarray)" args =>
-                                     [NDArrayHandle] ->
-                                       ArgsHMap "_contrib_DeformableConvolution(ndarray)" args ->
-                                         IO ()
-_contrib_DeformableConvolution_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("num_deformable_group",) . showValue <$>
-                 (args !? #num_deformable_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_DeformableConvolution(ndarray)" =
-     '[]
-
-_backward__contrib_DeformableConvolution ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward__contrib_DeformableConvolution(ndarray)"
-                                             args =>
-                                           ArgsHMap
-                                             "_backward__contrib_DeformableConvolution(ndarray)"
-                                             args
-                                             -> IO [NDArrayHandle]
-_backward__contrib_DeformableConvolution args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_DeformableConvolution_upd ::
-                                             forall args .
-                                               Fullfilled
-                                                 "_backward__contrib_DeformableConvolution(ndarray)"
-                                                 args =>
-                                               [NDArrayHandle] ->
-                                                 ArgsHMap
-                                                   "_backward__contrib_DeformableConvolution(ndarray)"
-                                                   args
-                                                   -> IO ()
-_backward__contrib_DeformableConvolution_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_ifft(ndarray)" =
-     '[ '("compute_size", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_ifft ::
-              forall args . Fullfilled "_contrib_ifft(ndarray)" args =>
-                ArgsHMap "_contrib_ifft(ndarray)" args -> IO [NDArrayHandle]
-_contrib_ifft args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_ifft_upd ::
-                  forall args . Fullfilled "_contrib_ifft(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_contrib_ifft(ndarray)" args -> IO ()
-_contrib_ifft_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__contrib_ifft(ndarray)" =
-     '[]
-
-_backward__contrib_ifft ::
-                        forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args =>
-                          ArgsHMap "_backward__contrib_ifft(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward__contrib_ifft args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_ifft_upd ::
-                            forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward__contrib_ifft(ndarray)" args -> IO ()
-_backward__contrib_ifft_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_SyncBatchNorm(ndarray)" = '[]
-
-_backward__contrib_SyncBatchNorm ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)" args =>
-                                   ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args ->
-                                     IO [NDArrayHandle]
-_backward__contrib_SyncBatchNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_SyncBatchNorm_upd ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)"
-                                         args =>
-                                       [NDArrayHandle] ->
-                                         ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args
-                                           -> IO ()
-_backward__contrib_SyncBatchNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_InstanceNorm(ndarray)" =
-     '[ '("eps", AttrOpt Float), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_InstanceNorm ::
-              forall args . Fullfilled "_InstanceNorm(ndarray)" args =>
-                ArgsHMap "_InstanceNorm(ndarray)" args -> IO [NDArrayHandle]
-_InstanceNorm args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_InstanceNorm_upd ::
-                  forall args . Fullfilled "_InstanceNorm(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_InstanceNorm(ndarray)" args -> IO ()
-_InstanceNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_InstanceNorm(ndarray)" = '[]
-
-_backward_InstanceNorm ::
-                       forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args =>
-                         ArgsHMap "_backward_InstanceNorm(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_InstanceNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_InstanceNorm_upd ::
-                           forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_InstanceNorm(ndarray)" args -> IO ()
-_backward_InstanceNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SVMOutput(ndarray)" =
-     '[ '("margin", AttrOpt Float),
-        '("regularization_coefficient", AttrOpt Float),
-        '("use_linear", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_SVMOutput ::
-           forall args . Fullfilled "_SVMOutput(ndarray)" args =>
-             ArgsHMap "_SVMOutput(ndarray)" args -> IO [NDArrayHandle]
-_SVMOutput args
-  = let scalarArgs
-          = catMaybes
-              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),
-               ("regularization_coefficient",) . showValue <$>
-                 (args !? #regularization_coefficient :: Maybe Float),
-               ("use_linear",) . showValue <$>
-                 (args !? #use_linear :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SVMOutput_upd ::
-               forall args . Fullfilled "_SVMOutput(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_SVMOutput(ndarray)" args -> IO ()
-_SVMOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),
-               ("regularization_coefficient",) . showValue <$>
-                 (args !? #regularization_coefficient :: Maybe Float),
-               ("use_linear",) . showValue <$>
-                 (args !? #use_linear :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SVMOutput(ndarray)" = '[]
-
-_backward_SVMOutput ::
-                    forall args . Fullfilled "_backward_SVMOutput(ndarray)" args =>
-                      ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO [NDArrayHandle]
-_backward_SVMOutput args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SVMOutput_upd ::
-                        forall args . Fullfilled "_backward_SVMOutput(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO ()
-_backward_SVMOutput_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_GridGenerator(ndarray)" =
-     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),
-        '("target_shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-_GridGenerator ::
-               forall args . Fullfilled "_GridGenerator(ndarray)" args =>
-                 ArgsHMap "_GridGenerator(ndarray)" args -> IO [NDArrayHandle]
-_GridGenerator args
-  = let scalarArgs
-          = catMaybes
-              [("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_GridGenerator_upd ::
-                   forall args . Fullfilled "_GridGenerator(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_GridGenerator(ndarray)" args -> IO ()
-_GridGenerator_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_GridGenerator(ndarray)" =
-     '[]
-
-_backward_GridGenerator ::
-                        forall args . Fullfilled "_backward_GridGenerator(ndarray)" args =>
-                          ArgsHMap "_backward_GridGenerator(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_GridGenerator args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_GridGenerator_upd ::
-                            forall args . Fullfilled "_backward_GridGenerator(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_GridGenerator(ndarray)" args -> IO ()
-_backward_GridGenerator_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Pad(ndarray)" = '[]
-
-_backward_Pad ::
-              forall args . Fullfilled "_backward_Pad(ndarray)" args =>
-                ArgsHMap "_backward_Pad(ndarray)" args -> IO [NDArrayHandle]
-_backward_Pad args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Pad_upd ::
-                  forall args . Fullfilled "_backward_Pad(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_Pad(ndarray)" args -> IO ()
-_backward_Pad_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Convolution_v1(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_Convolution_v1 ::
-                forall args . Fullfilled "_Convolution_v1(ndarray)" args =>
-                  ArgsHMap "_Convolution_v1(ndarray)" args -> IO [NDArrayHandle]
-_Convolution_v1 args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Convolution_v1_upd ::
-                    forall args . Fullfilled "_Convolution_v1(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_Convolution_v1(ndarray)" args -> IO ()
-_Convolution_v1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Convolution_v1(ndarray)" =
-     '[]
-
-_backward_Convolution_v1 ::
-                         forall args .
-                           Fullfilled "_backward_Convolution_v1(ndarray)" args =>
-                           ArgsHMap "_backward_Convolution_v1(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_Convolution_v1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Convolution_v1_upd ::
-                             forall args .
-                               Fullfilled "_backward_Convolution_v1(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_Convolution_v1(ndarray)" args -> IO ()
-_backward_Convolution_v1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SequenceReverse(ndarray)" =
-     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle),
-        '("sequence_length", AttrOpt NDArrayHandle)]
-
-_SequenceReverse ::
-                 forall args . Fullfilled "_SequenceReverse(ndarray)" args =>
-                   ArgsHMap "_SequenceReverse(ndarray)" args -> IO [NDArrayHandle]
-_SequenceReverse args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SequenceReverse_upd ::
-                     forall args . Fullfilled "_SequenceReverse(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_SequenceReverse(ndarray)" args -> IO ()
-_SequenceReverse_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SequenceReverse(ndarray)" =
-     '[]
-
-_backward_SequenceReverse ::
-                          forall args .
-                            Fullfilled "_backward_SequenceReverse(ndarray)" args =>
-                            ArgsHMap "_backward_SequenceReverse(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_SequenceReverse args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SequenceReverse_upd ::
-                              forall args .
-                                Fullfilled "_backward_SequenceReverse(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_SequenceReverse(ndarray)" args -> IO ()
-_backward_SequenceReverse_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SoftmaxOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
-        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_SoftmaxOutput ::
-               forall args . Fullfilled "_SoftmaxOutput(ndarray)" args =>
-                 ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO [NDArrayHandle]
-_SoftmaxOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SoftmaxOutput_upd ::
-                   forall args . Fullfilled "_SoftmaxOutput(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO ()
-_SoftmaxOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SoftmaxOutput(ndarray)" =
-     '[]
-
-_backward_SoftmaxOutput ::
-                        forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args =>
-                          ArgsHMap "_backward_SoftmaxOutput(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_SoftmaxOutput args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SoftmaxOutput_upd ::
-                            forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> IO ()
-_backward_SoftmaxOutput_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Softmax(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
-        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Softmax ::
-         forall args . Fullfilled "_Softmax(ndarray)" args =>
-           ArgsHMap "_Softmax(ndarray)" args -> IO [NDArrayHandle]
-_Softmax args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Softmax_upd ::
-             forall args . Fullfilled "_Softmax(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Softmax(ndarray)" args -> IO ()
-_Softmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Softmax(ndarray)" = '[]
-
-_backward_Softmax ::
-                  forall args . Fullfilled "_backward_Softmax(ndarray)" args =>
-                    ArgsHMap "_backward_Softmax(ndarray)" args -> IO [NDArrayHandle]
-_backward_Softmax args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Softmax_upd ::
-                      forall args . Fullfilled "_backward_Softmax(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_Softmax(ndarray)" args -> IO ()
-_backward_Softmax_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BilinearSampler(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("grid", AttrOpt NDArrayHandle)]
-
-_BilinearSampler ::
-                 forall args . Fullfilled "_BilinearSampler(ndarray)" args =>
-                   ArgsHMap "_BilinearSampler(ndarray)" args -> IO [NDArrayHandle]
-_BilinearSampler args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BilinearSampler_upd ::
-                     forall args . Fullfilled "_BilinearSampler(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_BilinearSampler(ndarray)" args -> IO ()
-_BilinearSampler_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_BilinearSampler(ndarray)" =
-     '[]
-
-_backward_BilinearSampler ::
-                          forall args .
-                            Fullfilled "_backward_BilinearSampler(ndarray)" args =>
-                            ArgsHMap "_backward_BilinearSampler(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_BilinearSampler args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_BilinearSampler_upd ::
-                              forall args .
-                                Fullfilled "_backward_BilinearSampler(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_BilinearSampler(ndarray)" args -> IO ()
-_backward_BilinearSampler_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_LeakyReLU(ndarray)" = '[]
-
-_backward_LeakyReLU ::
-                    forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args =>
-                      ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO [NDArrayHandle]
-_backward_LeakyReLU args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_LeakyReLU_upd ::
-                        forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO ()
-_backward_LeakyReLU_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Crop(ndarray)" =
-     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),
-        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_Crop ::
-      forall args . Fullfilled "_Crop(ndarray)" args =>
-        ArgsHMap "_Crop(ndarray)" args -> IO [NDArrayHandle]
-_Crop args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),
-               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),
-               ("center_crop",) . showValue <$>
-                 (args !? #center_crop :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Crop"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_Crop_upd ::
-          forall args . Fullfilled "_Crop(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_Crop(ndarray)" args -> IO ()
-_Crop_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),
-               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),
-               ("center_crop",) . showValue <$>
-                 (args !? #center_crop :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Crop"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Crop(ndarray)" = '[]
-
-_backward_Crop ::
-               forall args . Fullfilled "_backward_Crop(ndarray)" args =>
-                 ArgsHMap "_backward_Crop(ndarray)" args -> IO [NDArrayHandle]
-_backward_Crop args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Crop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Crop_upd ::
-                   forall args . Fullfilled "_backward_Crop(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_Crop(ndarray)" args -> IO ()
-_backward_Crop_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Crop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_ROIPooling(ndarray)" =
-     '[ '("pooled_size", AttrReq [Int]),
-        '("spatial_scale", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)]
-
-_ROIPooling ::
-            forall args . Fullfilled "_ROIPooling(ndarray)" args =>
-              ArgsHMap "_ROIPooling(ndarray)" args -> IO [NDArrayHandle]
-_ROIPooling args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_ROIPooling_upd ::
-                forall args . Fullfilled "_ROIPooling(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_ROIPooling(ndarray)" args -> IO ()
-_ROIPooling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_ROIPooling(ndarray)" = '[]
-
-_backward_ROIPooling ::
-                     forall args . Fullfilled "_backward_ROIPooling(ndarray)" args =>
-                       ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO [NDArrayHandle]
-_backward_ROIPooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_ROIPooling_upd ::
-                         forall args . Fullfilled "_backward_ROIPooling(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO ()
-_backward_ROIPooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SequenceLast(ndarray)" =
-     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle),
-        '("sequence_length", AttrOpt NDArrayHandle)]
-
-_SequenceLast ::
-              forall args . Fullfilled "_SequenceLast(ndarray)" args =>
-                ArgsHMap "_SequenceLast(ndarray)" args -> IO [NDArrayHandle]
-_SequenceLast args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SequenceLast_upd ::
-                  forall args . Fullfilled "_SequenceLast(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_SequenceLast(ndarray)" args -> IO ()
-_SequenceLast_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SequenceLast(ndarray)" = '[]
-
-_backward_SequenceLast ::
-                       forall args . Fullfilled "_backward_SequenceLast(ndarray)" args =>
-                         ArgsHMap "_backward_SequenceLast(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_SequenceLast args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SequenceLast_upd ::
-                           forall args . Fullfilled "_backward_SequenceLast(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_SequenceLast(ndarray)" args -> IO ()
-_backward_SequenceLast_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CrossDeviceCopy(ndarray)" = '[]
-
-_CrossDeviceCopy ::
-                 forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args =>
-                   ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO [NDArrayHandle]
-_CrossDeviceCopy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CrossDeviceCopy_upd ::
-                     forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO ()
-_CrossDeviceCopy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__CrossDeviceCopy(ndarray)" =
-     '[]
-
-_backward__CrossDeviceCopy ::
-                           forall args .
-                             Fullfilled "_backward__CrossDeviceCopy(ndarray)" args =>
-                             ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args ->
-                               IO [NDArrayHandle]
-_backward__CrossDeviceCopy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__CrossDeviceCopy_upd ::
-                               forall args .
-                                 Fullfilled "_backward__CrossDeviceCopy(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> IO ()
-_backward__CrossDeviceCopy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SpatialTransformer(ndarray)" =
-     '[ '("target_shape", AttrOpt [Int]),
-        '("transform_type", AttrReq (EnumType '["affine"])),
-        '("sampler_type", AttrReq (EnumType '["bilinear"])),
-        '("data", AttrOpt NDArrayHandle), '("loc", AttrOpt NDArrayHandle)]
-
-_SpatialTransformer ::
-                    forall args . Fullfilled "_SpatialTransformer(ndarray)" args =>
-                      ArgsHMap "_SpatialTransformer(ndarray)" args -> IO [NDArrayHandle]
-_SpatialTransformer args
-  = let scalarArgs
-          = catMaybes
-              [("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine"])),
-               ("sampler_type",) . showValue <$>
-                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SpatialTransformer_upd ::
-                        forall args . Fullfilled "_SpatialTransformer(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_SpatialTransformer(ndarray)" args -> IO ()
-_SpatialTransformer_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine"])),
-               ("sampler_type",) . showValue <$>
-                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SpatialTransformer(ndarray)"
-     = '[]
-
-_backward_SpatialTransformer ::
-                             forall args .
-                               Fullfilled "_backward_SpatialTransformer(ndarray)" args =>
-                               ArgsHMap "_backward_SpatialTransformer(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_backward_SpatialTransformer args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SpatialTransformer_upd ::
-                                 forall args .
-                                   Fullfilled "_backward_SpatialTransformer(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> IO ()
-_backward_SpatialTransformer_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SwapAxis(ndarray)" = '[]
-
-_backward_SwapAxis ::
-                   forall args . Fullfilled "_backward_SwapAxis(ndarray)" args =>
-                     ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO [NDArrayHandle]
-_backward_SwapAxis args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SwapAxis_upd ::
-                       forall args . Fullfilled "_backward_SwapAxis(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO ()
-_backward_SwapAxis_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_L2Normalization(ndarray)" =
-     '[ '("eps", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_L2Normalization ::
-                 forall args . Fullfilled "_L2Normalization(ndarray)" args =>
-                   ArgsHMap "_L2Normalization(ndarray)" args -> IO [NDArrayHandle]
-_L2Normalization args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["channel", "instance", "spatial"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_L2Normalization_upd ::
-                     forall args . Fullfilled "_L2Normalization(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_L2Normalization(ndarray)" args -> IO ()
-_L2Normalization_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["channel", "instance", "spatial"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_L2Normalization(ndarray)" =
-     '[]
-
-_backward_L2Normalization ::
-                          forall args .
-                            Fullfilled "_backward_L2Normalization(ndarray)" args =>
-                            ArgsHMap "_backward_L2Normalization(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_L2Normalization args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_L2Normalization_upd ::
-                              forall args .
-                                Fullfilled "_backward_L2Normalization(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_L2Normalization(ndarray)" args -> IO ()
-_backward_L2Normalization_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Correlation(ndarray)" =
-     '[ '("kernel_size", AttrOpt Int),
-        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),
-        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),
-        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt NDArrayHandle),
-        '("data2", AttrOpt NDArrayHandle)]
-
-_Correlation ::
-             forall args . Fullfilled "_Correlation(ndarray)" args =>
-               ArgsHMap "_Correlation(ndarray)" args -> IO [NDArrayHandle]
-_Correlation args
-  = let scalarArgs
-          = catMaybes
-              [("kernel_size",) . showValue <$>
-                 (args !? #kernel_size :: Maybe Int),
-               ("max_displacement",) . showValue <$>
-                 (args !? #max_displacement :: Maybe Int),
-               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),
-               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),
-               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),
-               ("is_multiply",) . showValue <$>
-                 (args !? #is_multiply :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle),
-               ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Correlation_upd ::
-                 forall args . Fullfilled "_Correlation(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_Correlation(ndarray)" args -> IO ()
-_Correlation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel_size",) . showValue <$>
-                 (args !? #kernel_size :: Maybe Int),
-               ("max_displacement",) . showValue <$>
-                 (args !? #max_displacement :: Maybe Int),
-               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),
-               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),
-               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),
-               ("is_multiply",) . showValue <$>
-                 (args !? #is_multiply :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle),
-               ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Correlation(ndarray)" = '[]
-
-_backward_Correlation ::
-                      forall args . Fullfilled "_backward_Correlation(ndarray)" args =>
-                        ArgsHMap "_backward_Correlation(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_Correlation args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Correlation_upd ::
-                          forall args . Fullfilled "_backward_Correlation(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_Correlation(ndarray)" args -> IO ()
-_backward_Correlation_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_IdentityAttachKLSparseReg(ndarray)" = '[]
-
-_backward_IdentityAttachKLSparseReg ::
-                                    forall args .
-                                      Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)"
-                                        args =>
-                                      ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" args
-                                        -> IO [NDArrayHandle]
-_backward_IdentityAttachKLSparseReg args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_IdentityAttachKLSparseReg_upd ::
-                                        forall args .
-                                          Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)"
-                                            args =>
-                                          [NDArrayHandle] ->
-                                            ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)"
-                                              args
-                                              -> IO ()
-_backward_IdentityAttachKLSparseReg_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_MakeLoss(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_MakeLoss ::
-          forall args . Fullfilled "_MakeLoss(ndarray)" args =>
-            ArgsHMap "_MakeLoss(ndarray)" args -> IO [NDArrayHandle]
-_MakeLoss args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_MakeLoss_upd ::
-              forall args . Fullfilled "_MakeLoss(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_MakeLoss(ndarray)" args -> IO ()
-_MakeLoss_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_MakeLoss(ndarray)" = '[]
-
-_backward_MakeLoss ::
-                   forall args . Fullfilled "_backward_MakeLoss(ndarray)" args =>
-                     ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO [NDArrayHandle]
-_backward_MakeLoss args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_MakeLoss_upd ::
-                       forall args . Fullfilled "_backward_MakeLoss(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO ()
-_backward_MakeLoss_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SliceChannel(ndarray)" = '[]
-
-_backward_SliceChannel ::
-                       forall args . Fullfilled "_backward_SliceChannel(ndarray)" args =>
-                         ArgsHMap "_backward_SliceChannel(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_SliceChannel args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SliceChannel_upd ::
-                           forall args . Fullfilled "_backward_SliceChannel(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_SliceChannel(ndarray)" args -> IO ()
-_backward_SliceChannel_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_RNN(ndarray)" =
-     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),
-        '("bidirectional", AttrOpt Bool),
-        '("mode",
-          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle),
-        '("parameters", AttrOpt NDArrayHandle),
-        '("state", AttrOpt NDArrayHandle),
-        '("state_cell", AttrOpt NDArrayHandle)]
-
-_RNN ::
-     forall args . Fullfilled "_RNN(ndarray)" args =>
-       ArgsHMap "_RNN(ndarray)" args -> IO [NDArrayHandle]
-_RNN args
-  = let scalarArgs
-          = catMaybes
-              [("state_size",) . showValue <$>
-                 (args !? #state_size :: Maybe Int),
-               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),
-               ("bidirectional",) . showValue <$>
-                 (args !? #bidirectional :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("state_outputs",) . showValue <$>
-                 (args !? #state_outputs :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle),
-               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),
-               ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_RNN_upd ::
-         forall args . Fullfilled "_RNN(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_RNN(ndarray)" args -> IO ()
-_RNN_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("state_size",) . showValue <$>
-                 (args !? #state_size :: Maybe Int),
-               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),
-               ("bidirectional",) . showValue <$>
-                 (args !? #bidirectional :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("state_outputs",) . showValue <$>
-                 (args !? #state_outputs :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle),
-               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),
-               ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_RNN(ndarray)" = '[]
-
-_backward_RNN ::
-              forall args . Fullfilled "_backward_RNN(ndarray)" args =>
-                ArgsHMap "_backward_RNN(ndarray)" args -> IO [NDArrayHandle]
-_backward_RNN args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_RNN_upd ::
-                  forall args . Fullfilled "_backward_RNN(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_RNN(ndarray)" args -> IO ()
-_backward_RNN_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Pooling_v1(ndarray)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])),
-        '("global_pool", AttrOpt Bool),
-        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Pooling_v1 ::
-            forall args . Fullfilled "_Pooling_v1(ndarray)" args =>
-              ArgsHMap "_Pooling_v1(ndarray)" args -> IO [NDArrayHandle]
-_Pooling_v1 args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Pooling_v1_upd ::
-                forall args . Fullfilled "_Pooling_v1(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_Pooling_v1(ndarray)" args -> IO ()
-_Pooling_v1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Pooling_v1(ndarray)" = '[]
-
-_backward_Pooling_v1 ::
-                     forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args =>
-                       ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO [NDArrayHandle]
-_backward_Pooling_v1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Pooling_v1_upd ::
-                         forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO ()
-_backward_Pooling_v1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_BatchNorm_v1(ndarray)" = '[]
-
-_backward_BatchNorm_v1 ::
-                       forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args =>
-                         ArgsHMap "_backward_BatchNorm_v1(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_BatchNorm_v1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_BatchNorm_v1_upd ::
-                           forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> IO ()
-_backward_BatchNorm_v1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SequenceMask(ndarray)" =
-     '[ '("use_sequence_length", AttrOpt Bool),
-        '("value", AttrOpt Float), '("axis", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle),
-        '("sequence_length", AttrOpt NDArrayHandle)]
-
-_SequenceMask ::
-              forall args . Fullfilled "_SequenceMask(ndarray)" args =>
-                ArgsHMap "_SequenceMask(ndarray)" args -> IO [NDArrayHandle]
-_SequenceMask args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("value",) . showValue <$> (args !? #value :: Maybe Float),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SequenceMask_upd ::
-                  forall args . Fullfilled "_SequenceMask(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_SequenceMask(ndarray)" args -> IO ()
-_SequenceMask_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("value",) . showValue <$> (args !? #value :: Maybe Float),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SequenceMask(ndarray)" = '[]
-
-_backward_SequenceMask ::
-                       forall args . Fullfilled "_backward_SequenceMask(ndarray)" args =>
-                         ArgsHMap "_backward_SequenceMask(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_SequenceMask args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SequenceMask_upd ::
-                           forall args . Fullfilled "_backward_SequenceMask(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_SequenceMask(ndarray)" args -> IO ()
-_backward_SequenceMask_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_set_value(ndarray)" =
-     '[ '("src", AttrOpt Float)]
-
-_set_value ::
-           forall args . Fullfilled "_set_value(ndarray)" args =>
-             ArgsHMap "_set_value(ndarray)" args -> IO [NDArrayHandle]
-_set_value args
-  = let scalarArgs
-          = catMaybes
-              [("src",) . showValue <$> (args !? #src :: Maybe Float)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_set_value"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_set_value_upd ::
-               forall args . Fullfilled "_set_value(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_set_value(ndarray)" args -> IO ()
-_set_value_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("src",) . showValue <$> (args !? #src :: Maybe Float)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_set_value"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_onehot_encode(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_onehot_encode ::
-               forall args . Fullfilled "_onehot_encode(ndarray)" args =>
-                 ArgsHMap "_onehot_encode(ndarray)" args -> IO [NDArrayHandle]
-_onehot_encode args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_onehot_encode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_onehot_encode_upd ::
-                   forall args . Fullfilled "_onehot_encode(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_onehot_encode(ndarray)" args -> IO ()
-_onehot_encode_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_onehot_encode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "choose_element_0index(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-choose_element_0index ::
-                      forall args . Fullfilled "choose_element_0index(ndarray)" args =>
-                        ArgsHMap "choose_element_0index(ndarray)" args ->
-                          IO [NDArrayHandle]
-choose_element_0index args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "choose_element_0index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-choose_element_0index_upd ::
-                          forall args . Fullfilled "choose_element_0index(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "choose_element_0index(ndarray)" args -> IO ()
-choose_element_0index_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "choose_element_0index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "fill_element_0index(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("mhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-fill_element_0index ::
-                    forall args . Fullfilled "fill_element_0index(ndarray)" args =>
-                      ArgsHMap "fill_element_0index(ndarray)" args -> IO [NDArrayHandle]
-fill_element_0index args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fill_element_0index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-fill_element_0index_upd ::
-                        forall args . Fullfilled "fill_element_0index(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "fill_element_0index(ndarray)" args -> IO ()
-fill_element_0index_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fill_element_0index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_imdecode(ndarray)" =
-     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),
-        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),
-        '("c", AttrOpt Int), '("size", AttrOpt Int),
-        '("mean", AttrOpt NDArrayHandle)]
-
-_imdecode ::
-          forall args . Fullfilled "_imdecode(ndarray)" args =>
-            ArgsHMap "_imdecode(ndarray)" args -> IO [NDArrayHandle]
-_imdecode args
-  = let scalarArgs
-          = catMaybes
-              [("index",) . showValue <$> (args !? #index :: Maybe Int),
-               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),
-               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),
-               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),
-               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),
-               ("c",) . showValue <$> (args !? #c :: Maybe Int),
-               ("size",) . showValue <$> (args !? #size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_imdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_imdecode_upd ::
-              forall args . Fullfilled "_imdecode(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_imdecode(ndarray)" args -> IO ()
-_imdecode_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("index",) . showValue <$> (args !? #index :: Maybe Int),
-               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),
-               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),
-               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),
-               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),
-               ("c",) . showValue <$> (args !? #c :: Maybe Int),
-               ("size",) . showValue <$> (args !? #size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_imdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
diff --git a/ops/1.3/MXNet/Base/Operators/Symbol.hs b/ops/1.3/MXNet/Base/Operators/Symbol.hs
deleted file mode 100644
--- a/ops/1.3/MXNet/Base/Operators/Symbol.hs
+++ /dev/null
@@ -1,11404 +0,0 @@
-module MXNet.Base.Operators.Symbol where
-import MXNet.Base.Raw
-import MXNet.Base.Spec.Operator
-import MXNet.Base.Spec.HMap
-import Data.Maybe (catMaybes, fromMaybe)
-
-type instance ParameterList "_sample_multinomial(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_sample_multinomial ::
-                    forall args . Fullfilled "_sample_multinomial(symbol)" args =>
-                      String ->
-                        ArgsHMap "_sample_multinomial(symbol)" args -> IO SymbolHandle
-_sample_multinomial name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_multinomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sample_multinomial(symbol)"
-     = '[]
-
-_backward_sample_multinomial ::
-                             forall args .
-                               Fullfilled "_backward_sample_multinomial(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_backward_sample_multinomial(symbol)" args ->
-                                   IO SymbolHandle
-_backward_sample_multinomial name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sample_multinomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_uniform(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("low", AttrOpt SymbolHandle), '("high", AttrOpt SymbolHandle)]
-
-_sample_uniform ::
-                forall args . Fullfilled "_sample_uniform(symbol)" args =>
-                  String ->
-                    ArgsHMap "_sample_uniform(symbol)" args -> IO SymbolHandle
-_sample_uniform name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("low",) <$> (args !? #low :: Maybe SymbolHandle),
-               ("high",) <$> (args !? #high :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_uniform"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_normal(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt SymbolHandle), '("sigma", AttrOpt SymbolHandle)]
-
-_sample_normal ::
-               forall args . Fullfilled "_sample_normal(symbol)" args =>
-                 String -> ArgsHMap "_sample_normal(symbol)" args -> IO SymbolHandle
-_sample_normal name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),
-               ("sigma",) <$> (args !? #sigma :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_normal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_gamma(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]
-
-_sample_gamma ::
-              forall args . Fullfilled "_sample_gamma(symbol)" args =>
-                String -> ArgsHMap "_sample_gamma(symbol)" args -> IO SymbolHandle
-_sample_gamma name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_exponential(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt SymbolHandle)]
-
-_sample_exponential ::
-                    forall args . Fullfilled "_sample_exponential(symbol)" args =>
-                      String ->
-                        ArgsHMap "_sample_exponential(symbol)" args -> IO SymbolHandle
-_sample_exponential name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_exponential"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_poisson(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt SymbolHandle)]
-
-_sample_poisson ::
-                forall args . Fullfilled "_sample_poisson(symbol)" args =>
-                  String ->
-                    ArgsHMap "_sample_poisson(symbol)" args -> IO SymbolHandle
-_sample_poisson name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_poisson"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_negative_binomial(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("k", AttrOpt SymbolHandle), '("p", AttrOpt SymbolHandle)]
-
-_sample_negative_binomial ::
-                          forall args .
-                            Fullfilled "_sample_negative_binomial(symbol)" args =>
-                            String ->
-                              ArgsHMap "_sample_negative_binomial(symbol)" args ->
-                                IO SymbolHandle
-_sample_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("k",) <$> (args !? #k :: Maybe SymbolHandle),
-               ("p",) <$> (args !? #p :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_sample_generalized_negative_binomial(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt SymbolHandle), '("alpha", AttrOpt SymbolHandle)]
-
-_sample_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_sample_generalized_negative_binomial(symbol)"
-                                          args =>
-                                        String ->
-                                          ArgsHMap "_sample_generalized_negative_binomial(symbol)"
-                                            args
-                                            -> IO SymbolHandle
-_sample_generalized_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_unique_zipfian(symbol)" =
-     '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])]
-
-_sample_unique_zipfian ::
-                       forall args . Fullfilled "_sample_unique_zipfian(symbol)" args =>
-                         String ->
-                           ArgsHMap "_sample_unique_zipfian(symbol)" args -> IO SymbolHandle
-_sample_unique_zipfian name args
-  = let scalarArgs
-          = catMaybes
-              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_unique_zipfian"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_uniform(symbol)" =
-     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_uniform ::
-                forall args . Fullfilled "_random_uniform(symbol)" args =>
-                  String ->
-                    ArgsHMap "_random_uniform(symbol)" args -> IO SymbolHandle
-_random_uniform name args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_normal(symbol)" =
-     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_normal ::
-               forall args . Fullfilled "_random_normal(symbol)" args =>
-                 String -> ArgsHMap "_random_normal(symbol)" args -> IO SymbolHandle
-_random_normal name args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_gamma(symbol)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_gamma ::
-              forall args . Fullfilled "_random_gamma(symbol)" args =>
-                String -> ArgsHMap "_random_gamma(symbol)" args -> IO SymbolHandle
-_random_gamma name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_exponential(symbol)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_exponential ::
-                    forall args . Fullfilled "_random_exponential(symbol)" args =>
-                      String ->
-                        ArgsHMap "_random_exponential(symbol)" args -> IO SymbolHandle
-_random_exponential name args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_poisson(symbol)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_poisson ::
-                forall args . Fullfilled "_random_poisson(symbol)" args =>
-                  String ->
-                    ArgsHMap "_random_poisson(symbol)" args -> IO SymbolHandle
-_random_poisson name args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_negative_binomial(symbol)" =
-     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_negative_binomial ::
-                          forall args .
-                            Fullfilled "_random_negative_binomial(symbol)" args =>
-                            String ->
-                              ArgsHMap "_random_negative_binomial(symbol)" args ->
-                                IO SymbolHandle
-_random_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_random_generalized_negative_binomial(symbol)" =
-     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_random_generalized_negative_binomial(symbol)"
-                                          args =>
-                                        String ->
-                                          ArgsHMap "_random_generalized_negative_binomial(symbol)"
-                                            args
-                                            -> IO SymbolHandle
-_random_generalized_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_shuffle(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_shuffle ::
-         forall args . Fullfilled "_shuffle(symbol)" args =>
-           String -> ArgsHMap "_shuffle(symbol)" args -> IO SymbolHandle
-_shuffle name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_shuffle"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Custom(symbol)" =
-     '[ '("op_type", AttrOpt String), '("data", AttrOpt [SymbolHandle])]
-
-_Custom ::
-        forall args .
-          (Fullfilled "_Custom(symbol)" args,
-           PopKey (ArgOf "_Custom(symbol)") args "data",
-           Dump (PopResult (ArgOf "_Custom(symbol)") args "data")) =>
-          String -> ArgsHMap "_Custom(symbol)" args -> IO SymbolHandle
-_Custom name args
-  = let scalarArgs = dump (pop args #data)
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "Custom"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_Custom(symbol)" = '[]
-
-_backward_Custom ::
-                 forall args . Fullfilled "_backward_Custom(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_Custom(symbol)" args -> IO SymbolHandle
-_backward_Custom name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Custom"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_power(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_power ::
-                forall args . Fullfilled "broadcast_power(symbol)" args =>
-                  String ->
-                    ArgsHMap "broadcast_power(symbol)" args -> IO SymbolHandle
-broadcast_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_power(symbol)" =
-     '[]
-
-_backward_broadcast_power ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_power(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_broadcast_power(symbol)" args ->
-                                IO SymbolHandle
-_backward_broadcast_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_maximum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_maximum ::
-                  forall args . Fullfilled "broadcast_maximum(symbol)" args =>
-                    String ->
-                      ArgsHMap "broadcast_maximum(symbol)" args -> IO SymbolHandle
-broadcast_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_maximum(symbol)" =
-     '[]
-
-_backward_broadcast_maximum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_maximum(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_broadcast_maximum(symbol)" args ->
-                                  IO SymbolHandle
-_backward_broadcast_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_minimum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_minimum ::
-                  forall args . Fullfilled "broadcast_minimum(symbol)" args =>
-                    String ->
-                      ArgsHMap "broadcast_minimum(symbol)" args -> IO SymbolHandle
-broadcast_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_minimum(symbol)" =
-     '[]
-
-_backward_broadcast_minimum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_minimum(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_broadcast_minimum(symbol)" args ->
-                                  IO SymbolHandle
-_backward_broadcast_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_hypot(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_hypot ::
-                forall args . Fullfilled "broadcast_hypot(symbol)" args =>
-                  String ->
-                    ArgsHMap "broadcast_hypot(symbol)" args -> IO SymbolHandle
-broadcast_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_hypot(symbol)" =
-     '[]
-
-_backward_broadcast_hypot ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_hypot(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_broadcast_hypot(symbol)" args ->
-                                IO SymbolHandle
-_backward_broadcast_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_equal ::
-       forall args . Fullfilled "_equal(symbol)" args =>
-         String -> ArgsHMap "_equal(symbol)" args -> IO SymbolHandle
-_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_not_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_not_equal ::
-           forall args . Fullfilled "_not_equal(symbol)" args =>
-             String -> ArgsHMap "_not_equal(symbol)" args -> IO SymbolHandle
-_not_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_greater ::
-         forall args . Fullfilled "_greater(symbol)" args =>
-           String -> ArgsHMap "_greater(symbol)" args -> IO SymbolHandle
-_greater name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_greater_equal ::
-               forall args . Fullfilled "_greater_equal(symbol)" args =>
-                 String -> ArgsHMap "_greater_equal(symbol)" args -> IO SymbolHandle
-_greater_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_lesser ::
-        forall args . Fullfilled "_lesser(symbol)" args =>
-          String -> ArgsHMap "_lesser(symbol)" args -> IO SymbolHandle
-_lesser name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_lesser_equal ::
-              forall args . Fullfilled "_lesser_equal(symbol)" args =>
-                String -> ArgsHMap "_lesser_equal(symbol)" args -> IO SymbolHandle
-_lesser_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_and(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_logical_and ::
-             forall args . Fullfilled "_logical_and(symbol)" args =>
-               String -> ArgsHMap "_logical_and(symbol)" args -> IO SymbolHandle
-_logical_and name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_or(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_logical_or ::
-            forall args . Fullfilled "_logical_or(symbol)" args =>
-              String -> ArgsHMap "_logical_or(symbol)" args -> IO SymbolHandle
-_logical_or name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_xor(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_logical_xor ::
-             forall args . Fullfilled "_logical_xor(symbol)" args =>
-               String -> ArgsHMap "_logical_xor(symbol)" args -> IO SymbolHandle
-_logical_xor name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_power(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_power ::
-       forall args . Fullfilled "_power(symbol)" args =>
-         String -> ArgsHMap "_power(symbol)" args -> IO SymbolHandle
-_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_power(symbol)" = '[]
-
-_backward_power ::
-                forall args . Fullfilled "_backward_power(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_power(symbol)" args -> IO SymbolHandle
-_backward_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_maximum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_maximum ::
-         forall args . Fullfilled "_maximum(symbol)" args =>
-           String -> ArgsHMap "_maximum(symbol)" args -> IO SymbolHandle
-_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_maximum(symbol)" = '[]
-
-_backward_maximum ::
-                  forall args . Fullfilled "_backward_maximum(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_maximum(symbol)" args -> IO SymbolHandle
-_backward_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_minimum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_minimum ::
-         forall args . Fullfilled "_minimum(symbol)" args =>
-           String -> ArgsHMap "_minimum(symbol)" args -> IO SymbolHandle
-_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_minimum(symbol)" = '[]
-
-_backward_minimum ::
-                  forall args . Fullfilled "_backward_minimum(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_minimum(symbol)" args -> IO SymbolHandle
-_backward_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_hypot(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_hypot ::
-       forall args . Fullfilled "_hypot(symbol)" args =>
-         String -> ArgsHMap "_hypot(symbol)" args -> IO SymbolHandle
-_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_hypot(symbol)" = '[]
-
-_backward_hypot ::
-                forall args . Fullfilled "_backward_hypot(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_hypot(symbol)" args -> IO SymbolHandle
-_backward_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_square_sum(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-_square_sum ::
-            forall args . Fullfilled "_square_sum(symbol)" args =>
-              String -> ArgsHMap "_square_sum(symbol)" args -> IO SymbolHandle
-_square_sum name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_square_sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_square_sum(symbol)" = '[]
-
-_backward_square_sum ::
-                     forall args . Fullfilled "_backward_square_sum(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_square_sum(symbol)" args -> IO SymbolHandle
-_backward_square_sum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square_sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "add_n(symbol)" =
-     '[ '("args", AttrOpt [SymbolHandle])]
-
-add_n ::
-      forall args . Fullfilled "add_n(symbol)" args =>
-        String -> ArgsHMap "add_n(symbol)" args -> IO SymbolHandle
-add_n name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "add_n"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_zeros(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_zeros ::
-       forall args . Fullfilled "_zeros(symbol)" args =>
-         String -> ArgsHMap "_zeros(symbol)" args -> IO SymbolHandle
-_zeros name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_eye(symbol)" =
-     '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_eye ::
-     forall args . Fullfilled "_eye(symbol)" args =>
-       String -> ArgsHMap "_eye(symbol)" args -> IO SymbolHandle
-_eye name args
-  = let scalarArgs
-          = catMaybes
-              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),
-               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_eye"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_ones(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_ones ::
-      forall args . Fullfilled "_ones(symbol)" args =>
-        String -> ArgsHMap "_ones(symbol)" args -> IO SymbolHandle
-_ones name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ones"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_full(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("value", AttrReq Double)]
-
-_full ::
-      forall args . Fullfilled "_full(symbol)" args =>
-        String -> ArgsHMap "_full(symbol)" args -> IO SymbolHandle
-_full name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_full"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_arange(symbol)" =
-     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),
-        '("step", AttrOpt Double), '("repeat", AttrOpt Int),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_arange ::
-        forall args . Fullfilled "_arange(symbol)" args =>
-          String -> ArgsHMap "_arange(symbol)" args -> IO SymbolHandle
-_arange name args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_arange"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "zeros_like(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-zeros_like ::
-           forall args . Fullfilled "zeros_like(symbol)" args =>
-             String -> ArgsHMap "zeros_like(symbol)" args -> IO SymbolHandle
-zeros_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "zeros_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ones_like(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-ones_like ::
-          forall args . Fullfilled "ones_like(symbol)" args =>
-            String -> ArgsHMap "ones_like(symbol)" args -> IO SymbolHandle
-ones_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ones_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_add(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_add ::
-              forall args . Fullfilled "broadcast_add(symbol)" args =>
-                String -> ArgsHMap "broadcast_add(symbol)" args -> IO SymbolHandle
-broadcast_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_add(symbol)" = '[]
-
-_backward_broadcast_add ::
-                        forall args . Fullfilled "_backward_broadcast_add(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_add(symbol)" args -> IO SymbolHandle
-_backward_broadcast_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_sub(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_sub ::
-              forall args . Fullfilled "broadcast_sub(symbol)" args =>
-                String -> ArgsHMap "broadcast_sub(symbol)" args -> IO SymbolHandle
-broadcast_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_sub(symbol)" = '[]
-
-_backward_broadcast_sub ::
-                        forall args . Fullfilled "_backward_broadcast_sub(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_sub(symbol)" args -> IO SymbolHandle
-_backward_broadcast_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_mul(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_mul ::
-              forall args . Fullfilled "broadcast_mul(symbol)" args =>
-                String -> ArgsHMap "broadcast_mul(symbol)" args -> IO SymbolHandle
-broadcast_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_mul(symbol)" = '[]
-
-_backward_broadcast_mul ::
-                        forall args . Fullfilled "_backward_broadcast_mul(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_mul(symbol)" args -> IO SymbolHandle
-_backward_broadcast_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_div(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_div ::
-              forall args . Fullfilled "broadcast_div(symbol)" args =>
-                String -> ArgsHMap "broadcast_div(symbol)" args -> IO SymbolHandle
-broadcast_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_div(symbol)" = '[]
-
-_backward_broadcast_div ::
-                        forall args . Fullfilled "_backward_broadcast_div(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_div(symbol)" args -> IO SymbolHandle
-_backward_broadcast_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_mod(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_mod ::
-              forall args . Fullfilled "broadcast_mod(symbol)" args =>
-                String -> ArgsHMap "broadcast_mod(symbol)" args -> IO SymbolHandle
-broadcast_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_mod(symbol)" = '[]
-
-_backward_broadcast_mod ::
-                        forall args . Fullfilled "_backward_broadcast_mod(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_mod(symbol)" args -> IO SymbolHandle
-_backward_broadcast_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_gemm(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),
-        '("axis", AttrOpt Int), '("_A", AttrOpt SymbolHandle),
-        '("_B", AttrOpt SymbolHandle), '("_C", AttrOpt SymbolHandle)]
-
-_linalg_gemm ::
-             forall args . Fullfilled "_linalg_gemm(symbol)" args =>
-               String -> ArgsHMap "_linalg_gemm(symbol)" args -> IO SymbolHandle
-_linalg_gemm name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle),
-               ("_C",) <$> (args !? #_C :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_gemm(symbol)" = '[]
-
-_backward_linalg_gemm ::
-                      forall args . Fullfilled "_backward_linalg_gemm(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_gemm(symbol)" args -> IO SymbolHandle
-_backward_linalg_gemm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_gemm2(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("axis", AttrOpt Int),
-        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)]
-
-_linalg_gemm2 ::
-              forall args . Fullfilled "_linalg_gemm2(symbol)" args =>
-                String -> ArgsHMap "_linalg_gemm2(symbol)" args -> IO SymbolHandle
-_linalg_gemm2 name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_gemm2(symbol)" = '[]
-
-_backward_linalg_gemm2 ::
-                       forall args . Fullfilled "_backward_linalg_gemm2(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_gemm2(symbol)" args -> IO SymbolHandle
-_backward_linalg_gemm2 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_potrf(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_potrf ::
-              forall args . Fullfilled "_linalg_potrf(symbol)" args =>
-                String -> ArgsHMap "_linalg_potrf(symbol)" args -> IO SymbolHandle
-_linalg_potrf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potrf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_potrf(symbol)" = '[]
-
-_backward_linalg_potrf ::
-                       forall args . Fullfilled "_backward_linalg_potrf(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_potrf(symbol)" args -> IO SymbolHandle
-_backward_linalg_potrf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potrf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_potri(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_potri ::
-              forall args . Fullfilled "_linalg_potri(symbol)" args =>
-                String -> ArgsHMap "_linalg_potri(symbol)" args -> IO SymbolHandle
-_linalg_potri name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potri"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_potri(symbol)" = '[]
-
-_backward_linalg_potri ::
-                       forall args . Fullfilled "_backward_linalg_potri(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_potri(symbol)" args -> IO SymbolHandle
-_backward_linalg_potri name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potri"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_trmm(symbol)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle),
-        '("_B", AttrOpt SymbolHandle)]
-
-_linalg_trmm ::
-             forall args . Fullfilled "_linalg_trmm(symbol)" args =>
-               String -> ArgsHMap "_linalg_trmm(symbol)" args -> IO SymbolHandle
-_linalg_trmm name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trmm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_trmm(symbol)" = '[]
-
-_backward_linalg_trmm ::
-                      forall args . Fullfilled "_backward_linalg_trmm(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_trmm(symbol)" args -> IO SymbolHandle
-_backward_linalg_trmm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trmm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_trsm(symbol)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("_A", AttrOpt SymbolHandle),
-        '("_B", AttrOpt SymbolHandle)]
-
-_linalg_trsm ::
-             forall args . Fullfilled "_linalg_trsm(symbol)" args =>
-               String -> ArgsHMap "_linalg_trsm(symbol)" args -> IO SymbolHandle
-_linalg_trsm name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trsm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_trsm(symbol)" = '[]
-
-_backward_linalg_trsm ::
-                      forall args . Fullfilled "_backward_linalg_trsm(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_trsm(symbol)" args -> IO SymbolHandle
-_backward_linalg_trsm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trsm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_sumlogdiag(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_sumlogdiag ::
-                   forall args . Fullfilled "_linalg_sumlogdiag(symbol)" args =>
-                     String ->
-                       ArgsHMap "_linalg_sumlogdiag(symbol)" args -> IO SymbolHandle
-_linalg_sumlogdiag name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_sumlogdiag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_sumlogdiag(symbol)" =
-     '[]
-
-_backward_linalg_sumlogdiag ::
-                            forall args .
-                              Fullfilled "_backward_linalg_sumlogdiag(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_linalg_sumlogdiag(symbol)" args ->
-                                  IO SymbolHandle
-_backward_linalg_sumlogdiag name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_syrk(symbol)" =
-     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt SymbolHandle)]
-
-_linalg_syrk ::
-             forall args . Fullfilled "_linalg_syrk(symbol)" args =>
-               String -> ArgsHMap "_linalg_syrk(symbol)" args -> IO SymbolHandle
-_linalg_syrk name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syrk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_syrk(symbol)" = '[]
-
-_backward_linalg_syrk ::
-                      forall args . Fullfilled "_backward_linalg_syrk(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_syrk(symbol)" args -> IO SymbolHandle
-_backward_linalg_syrk name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syrk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_gelqf(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_gelqf ::
-              forall args . Fullfilled "_linalg_gelqf(symbol)" args =>
-                String -> ArgsHMap "_linalg_gelqf(symbol)" args -> IO SymbolHandle
-_linalg_gelqf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gelqf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_gelqf(symbol)" = '[]
-
-_backward_linalg_gelqf ::
-                       forall args . Fullfilled "_backward_linalg_gelqf(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_gelqf(symbol)" args -> IO SymbolHandle
-_backward_linalg_gelqf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gelqf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_syevd(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_syevd ::
-              forall args . Fullfilled "_linalg_syevd(symbol)" args =>
-                String -> ArgsHMap "_linalg_syevd(symbol)" args -> IO SymbolHandle
-_linalg_syevd name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syevd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_syevd(symbol)" = '[]
-
-_backward_linalg_syevd ::
-                       forall args . Fullfilled "_backward_linalg_syevd(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_syevd(symbol)" args -> IO SymbolHandle
-_backward_linalg_syevd name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syevd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_histogram(symbol)" =
-     '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle), '("bins", AttrOpt SymbolHandle)]
-
-_histogram ::
-           forall args . Fullfilled "_histogram(symbol)" args =>
-             String -> ArgsHMap "_histogram(symbol)" args -> IO SymbolHandle
-_histogram name args
-  = let scalarArgs
-          = catMaybes
-              [("bin_cnt",) . showValue <$>
-                 (args !? #bin_cnt :: Maybe (Maybe Int)),
-               ("range",) . showValue <$> (args !? #range :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("bins",) <$> (args !? #bins :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_histogram"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cast_storage(symbol)" =
-     '[ '("stype",
-          AttrReq (EnumType '["csr", "default", "row_sparse"])),
-        '("data", AttrOpt SymbolHandle)]
-
-cast_storage ::
-             forall args . Fullfilled "cast_storage(symbol)" args =>
-               String -> ArgsHMap "cast_storage(symbol)" args -> IO SymbolHandle
-cast_storage name args
-  = let scalarArgs
-          = catMaybes
-              [("stype",) . showValue <$>
-                 (args !? #stype ::
-                    Maybe (EnumType '["csr", "default", "row_sparse"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cast_storage"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_equal_scalar ::
-              forall args . Fullfilled "_equal_scalar(symbol)" args =>
-                String -> ArgsHMap "_equal_scalar(symbol)" args -> IO SymbolHandle
-_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_not_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_not_equal_scalar ::
-                  forall args . Fullfilled "_not_equal_scalar(symbol)" args =>
-                    String ->
-                      ArgsHMap "_not_equal_scalar(symbol)" args -> IO SymbolHandle
-_not_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_greater_scalar ::
-                forall args . Fullfilled "_greater_scalar(symbol)" args =>
-                  String ->
-                    ArgsHMap "_greater_scalar(symbol)" args -> IO SymbolHandle
-_greater_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_greater_equal_scalar ::
-                      forall args . Fullfilled "_greater_equal_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_greater_equal_scalar(symbol)" args -> IO SymbolHandle
-_greater_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_lesser_scalar ::
-               forall args . Fullfilled "_lesser_scalar(symbol)" args =>
-                 String -> ArgsHMap "_lesser_scalar(symbol)" args -> IO SymbolHandle
-_lesser_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_lesser_equal_scalar ::
-                     forall args . Fullfilled "_lesser_equal_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_lesser_equal_scalar(symbol)" args -> IO SymbolHandle
-_lesser_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_and_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_logical_and_scalar ::
-                    forall args . Fullfilled "_logical_and_scalar(symbol)" args =>
-                      String ->
-                        ArgsHMap "_logical_and_scalar(symbol)" args -> IO SymbolHandle
-_logical_and_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_or_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_logical_or_scalar ::
-                   forall args . Fullfilled "_logical_or_scalar(symbol)" args =>
-                     String ->
-                       ArgsHMap "_logical_or_scalar(symbol)" args -> IO SymbolHandle
-_logical_or_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_xor_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_logical_xor_scalar ::
-                    forall args . Fullfilled "_logical_xor_scalar(symbol)" args =>
-                      String ->
-                        ArgsHMap "_logical_xor_scalar(symbol)" args -> IO SymbolHandle
-_logical_xor_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "relu(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-relu ::
-     forall args . Fullfilled "relu(symbol)" args =>
-       String -> ArgsHMap "relu(symbol)" args -> IO SymbolHandle
-relu name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "relu"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_relu(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_relu ::
-               forall args . Fullfilled "_backward_relu(symbol)" args =>
-                 String -> ArgsHMap "_backward_relu(symbol)" args -> IO SymbolHandle
-_backward_relu name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_relu"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sigmoid(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sigmoid ::
-        forall args . Fullfilled "sigmoid(symbol)" args =>
-          String -> ArgsHMap "sigmoid(symbol)" args -> IO SymbolHandle
-sigmoid name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sigmoid"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sigmoid(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sigmoid ::
-                  forall args . Fullfilled "_backward_sigmoid(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_sigmoid(symbol)" args -> IO SymbolHandle
-_backward_sigmoid name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sigmoid"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "hard_sigmoid(symbol)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-hard_sigmoid ::
-             forall args . Fullfilled "hard_sigmoid(symbol)" args =>
-               String -> ArgsHMap "hard_sigmoid(symbol)" args -> IO SymbolHandle
-hard_sigmoid name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "hard_sigmoid"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_hard_sigmoid(symbol)" = '[]
-
-_backward_hard_sigmoid ::
-                       forall args . Fullfilled "_backward_hard_sigmoid(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_hard_sigmoid(symbol)" args -> IO SymbolHandle
-_backward_hard_sigmoid name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hard_sigmoid"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "softsign(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-softsign ::
-         forall args . Fullfilled "softsign(symbol)" args =>
-           String -> ArgsHMap "softsign(symbol)" args -> IO SymbolHandle
-softsign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softsign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_softsign(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_softsign ::
-                   forall args . Fullfilled "_backward_softsign(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_softsign(symbol)" args -> IO SymbolHandle
-_backward_softsign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softsign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_copy(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_copy ::
-      forall args . Fullfilled "_copy(symbol)" args =>
-        String -> ArgsHMap "_copy(symbol)" args -> IO SymbolHandle
-_copy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_copy(symbol)" = '[]
-
-_backward_copy ::
-               forall args . Fullfilled "_backward_copy(symbol)" args =>
-                 String -> ArgsHMap "_backward_copy(symbol)" args -> IO SymbolHandle
-_backward_copy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_copy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BlockGrad(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_BlockGrad ::
-           forall args . Fullfilled "_BlockGrad(symbol)" args =>
-             String -> ArgsHMap "_BlockGrad(symbol)" args -> IO SymbolHandle
-_BlockGrad name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BlockGrad"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "make_loss(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-make_loss ::
-          forall args . Fullfilled "make_loss(symbol)" args =>
-            String -> ArgsHMap "make_loss(symbol)" args -> IO SymbolHandle
-make_loss name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "make_loss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_identity_with_attr_like_rhs(symbol)"
-     =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_identity_with_attr_like_rhs ::
-                             forall args .
-                               Fullfilled "_identity_with_attr_like_rhs(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_identity_with_attr_like_rhs(symbol)" args ->
-                                   IO SymbolHandle
-_identity_with_attr_like_rhs name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "reshape_like(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-reshape_like ::
-             forall args . Fullfilled "reshape_like(symbol)" args =>
-               String -> ArgsHMap "reshape_like(symbol)" args -> IO SymbolHandle
-reshape_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reshape_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "shape_array(symbol)" =
-     '[ '("lhs_begin", AttrOpt (Maybe Int)),
-        '("lhs_end", AttrOpt (Maybe Int)),
-        '("rhs_begin", AttrOpt (Maybe Int)),
-        '("rhs_end", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)]
-
-shape_array ::
-            forall args . Fullfilled "shape_array(symbol)" args =>
-              String -> ArgsHMap "shape_array(symbol)" args -> IO SymbolHandle
-shape_array name args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_begin",) . showValue <$>
-                 (args !? #lhs_begin :: Maybe (Maybe Int)),
-               ("lhs_end",) . showValue <$>
-                 (args !? #lhs_end :: Maybe (Maybe Int)),
-               ("rhs_begin",) . showValue <$>
-                 (args !? #rhs_begin :: Maybe (Maybe Int)),
-               ("rhs_end",) . showValue <$>
-                 (args !? #rhs_end :: Maybe (Maybe Int))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "shape_array"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "size_array(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-size_array ::
-           forall args . Fullfilled "size_array(symbol)" args =>
-             String -> ArgsHMap "size_array(symbol)" args -> IO SymbolHandle
-size_array name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "size_array"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Cast(symbol)" =
-     '[ '("dtype",
-          AttrReq
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_Cast ::
-      forall args . Fullfilled "_Cast(symbol)" args =>
-        String -> ArgsHMap "_Cast(symbol)" args -> IO SymbolHandle
-_Cast name args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Cast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cast(symbol)" = '[]
-
-_backward_cast ::
-               forall args . Fullfilled "_backward_cast(symbol)" args =>
-                 String -> ArgsHMap "_backward_cast(symbol)" args -> IO SymbolHandle
-_backward_cast name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "negative(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-negative ::
-         forall args . Fullfilled "negative(symbol)" args =>
-           String -> ArgsHMap "negative(symbol)" args -> IO SymbolHandle
-negative name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "negative"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "reciprocal(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-reciprocal ::
-           forall args . Fullfilled "reciprocal(symbol)" args =>
-             String -> ArgsHMap "reciprocal(symbol)" args -> IO SymbolHandle
-reciprocal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reciprocal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_reciprocal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_reciprocal ::
-                     forall args . Fullfilled "_backward_reciprocal(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_reciprocal(symbol)" args -> IO SymbolHandle
-_backward_reciprocal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reciprocal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "abs(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-abs ::
-    forall args . Fullfilled "abs(symbol)" args =>
-      String -> ArgsHMap "abs(symbol)" args -> IO SymbolHandle
-abs name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "abs"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_abs(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_abs ::
-              forall args . Fullfilled "_backward_abs(symbol)" args =>
-                String -> ArgsHMap "_backward_abs(symbol)" args -> IO SymbolHandle
-_backward_abs name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_abs"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sign(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sign ::
-     forall args . Fullfilled "sign(symbol)" args =>
-       String -> ArgsHMap "sign(symbol)" args -> IO SymbolHandle
-sign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sign(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sign ::
-               forall args . Fullfilled "_backward_sign(symbol)" args =>
-                 String -> ArgsHMap "_backward_sign(symbol)" args -> IO SymbolHandle
-_backward_sign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "round(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-round ::
-      forall args . Fullfilled "round(symbol)" args =>
-        String -> ArgsHMap "round(symbol)" args -> IO SymbolHandle
-round name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "round"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rint(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-rint ::
-     forall args . Fullfilled "rint(symbol)" args =>
-       String -> ArgsHMap "rint(symbol)" args -> IO SymbolHandle
-rint name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rint"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ceil(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-ceil ::
-     forall args . Fullfilled "ceil(symbol)" args =>
-       String -> ArgsHMap "ceil(symbol)" args -> IO SymbolHandle
-ceil name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ceil"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "floor(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-floor ::
-      forall args . Fullfilled "floor(symbol)" args =>
-        String -> ArgsHMap "floor(symbol)" args -> IO SymbolHandle
-floor name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "floor"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "trunc(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-trunc ::
-      forall args . Fullfilled "trunc(symbol)" args =>
-        String -> ArgsHMap "trunc(symbol)" args -> IO SymbolHandle
-trunc name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "trunc"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "fix(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-fix ::
-    forall args . Fullfilled "fix(symbol)" args =>
-      String -> ArgsHMap "fix(symbol)" args -> IO SymbolHandle
-fix name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fix"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "square(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-square ::
-       forall args . Fullfilled "square(symbol)" args =>
-         String -> ArgsHMap "square(symbol)" args -> IO SymbolHandle
-square name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "square"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_square(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_square ::
-                 forall args . Fullfilled "_backward_square(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_square(symbol)" args -> IO SymbolHandle
-_backward_square name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sqrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sqrt ::
-     forall args . Fullfilled "sqrt(symbol)" args =>
-       String -> ArgsHMap "sqrt(symbol)" args -> IO SymbolHandle
-sqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sqrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sqrt ::
-               forall args . Fullfilled "_backward_sqrt(symbol)" args =>
-                 String -> ArgsHMap "_backward_sqrt(symbol)" args -> IO SymbolHandle
-_backward_sqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rsqrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-rsqrt ::
-      forall args . Fullfilled "rsqrt(symbol)" args =>
-        String -> ArgsHMap "rsqrt(symbol)" args -> IO SymbolHandle
-rsqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rsqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rsqrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rsqrt ::
-                forall args . Fullfilled "_backward_rsqrt(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_rsqrt(symbol)" args -> IO SymbolHandle
-_backward_rsqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rsqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cbrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-cbrt ::
-     forall args . Fullfilled "cbrt(symbol)" args =>
-       String -> ArgsHMap "cbrt(symbol)" args -> IO SymbolHandle
-cbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cbrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_cbrt ::
-               forall args . Fullfilled "_backward_cbrt(symbol)" args =>
-                 String -> ArgsHMap "_backward_cbrt(symbol)" args -> IO SymbolHandle
-_backward_cbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rcbrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-rcbrt ::
-      forall args . Fullfilled "rcbrt(symbol)" args =>
-        String -> ArgsHMap "rcbrt(symbol)" args -> IO SymbolHandle
-rcbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rcbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rcbrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rcbrt ::
-                forall args . Fullfilled "_backward_rcbrt(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_rcbrt(symbol)" args -> IO SymbolHandle
-_backward_rcbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rcbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "exp(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-exp ::
-    forall args . Fullfilled "exp(symbol)" args =>
-      String -> ArgsHMap "exp(symbol)" args -> IO SymbolHandle
-exp name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "exp"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log ::
-    forall args . Fullfilled "log(symbol)" args =>
-      String -> ArgsHMap "log(symbol)" args -> IO SymbolHandle
-log name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log10(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log10 ::
-      forall args . Fullfilled "log10(symbol)" args =>
-        String -> ArgsHMap "log10(symbol)" args -> IO SymbolHandle
-log10 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log10"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log2(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log2 ::
-     forall args . Fullfilled "log2(symbol)" args =>
-       String -> ArgsHMap "log2(symbol)" args -> IO SymbolHandle
-log2 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log ::
-              forall args . Fullfilled "_backward_log(symbol)" args =>
-                String -> ArgsHMap "_backward_log(symbol)" args -> IO SymbolHandle
-_backward_log name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log10(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log10 ::
-                forall args . Fullfilled "_backward_log10(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_log10(symbol)" args -> IO SymbolHandle
-_backward_log10 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log10"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log2(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log2 ::
-               forall args . Fullfilled "_backward_log2(symbol)" args =>
-                 String -> ArgsHMap "_backward_log2(symbol)" args -> IO SymbolHandle
-_backward_log2 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log1p(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log1p ::
-      forall args . Fullfilled "log1p(symbol)" args =>
-        String -> ArgsHMap "log1p(symbol)" args -> IO SymbolHandle
-log1p name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log1p"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log1p(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log1p ::
-                forall args . Fullfilled "_backward_log1p(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_log1p(symbol)" args -> IO SymbolHandle
-_backward_log1p name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log1p"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "expm1(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-expm1 ::
-      forall args . Fullfilled "expm1(symbol)" args =>
-        String -> ArgsHMap "expm1(symbol)" args -> IO SymbolHandle
-expm1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expm1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_expm1(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_expm1 ::
-                forall args . Fullfilled "_backward_expm1(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_expm1(symbol)" args -> IO SymbolHandle
-_backward_expm1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_expm1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "gamma(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-gamma ::
-      forall args . Fullfilled "gamma(symbol)" args =>
-        String -> ArgsHMap "gamma(symbol)" args -> IO SymbolHandle
-gamma name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_gamma(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_gamma ::
-                forall args . Fullfilled "_backward_gamma(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_gamma(symbol)" args -> IO SymbolHandle
-_backward_gamma name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "gammaln(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-gammaln ::
-        forall args . Fullfilled "gammaln(symbol)" args =>
-          String -> ArgsHMap "gammaln(symbol)" args -> IO SymbolHandle
-gammaln name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gammaln"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_gammaln(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_gammaln ::
-                  forall args . Fullfilled "_backward_gammaln(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_gammaln(symbol)" args -> IO SymbolHandle
-_backward_gammaln name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gammaln"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "logical_not(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-logical_not ::
-            forall args . Fullfilled "logical_not(symbol)" args =>
-              String -> ArgsHMap "logical_not(symbol)" args -> IO SymbolHandle
-logical_not name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "logical_not"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sum(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-sum ::
-    forall args . Fullfilled "sum(symbol)" args =>
-      String -> ArgsHMap "sum(symbol)" args -> IO SymbolHandle
-sum name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sum(symbol)" = '[]
-
-_backward_sum ::
-              forall args . Fullfilled "_backward_sum(symbol)" args =>
-                String -> ArgsHMap "_backward_sum(symbol)" args -> IO SymbolHandle
-_backward_sum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "mean(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-mean ::
-     forall args . Fullfilled "mean(symbol)" args =>
-       String -> ArgsHMap "mean(symbol)" args -> IO SymbolHandle
-mean name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mean"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mean(symbol)" = '[]
-
-_backward_mean ::
-               forall args . Fullfilled "_backward_mean(symbol)" args =>
-                 String -> ArgsHMap "_backward_mean(symbol)" args -> IO SymbolHandle
-_backward_mean name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mean"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "prod(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-prod ::
-     forall args . Fullfilled "prod(symbol)" args =>
-       String -> ArgsHMap "prod(symbol)" args -> IO SymbolHandle
-prod name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "prod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_prod(symbol)" = '[]
-
-_backward_prod ::
-               forall args . Fullfilled "_backward_prod(symbol)" args =>
-                 String -> ArgsHMap "_backward_prod(symbol)" args -> IO SymbolHandle
-_backward_prod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_prod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "nansum(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-nansum ::
-       forall args . Fullfilled "nansum(symbol)" args =>
-         String -> ArgsHMap "nansum(symbol)" args -> IO SymbolHandle
-nansum name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nansum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_nansum(symbol)" = '[]
-
-_backward_nansum ::
-                 forall args . Fullfilled "_backward_nansum(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_nansum(symbol)" args -> IO SymbolHandle
-_backward_nansum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nansum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "nanprod(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-nanprod ::
-        forall args . Fullfilled "nanprod(symbol)" args =>
-          String -> ArgsHMap "nanprod(symbol)" args -> IO SymbolHandle
-nanprod name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nanprod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_nanprod(symbol)" = '[]
-
-_backward_nanprod ::
-                  forall args . Fullfilled "_backward_nanprod(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_nanprod(symbol)" args -> IO SymbolHandle
-_backward_nanprod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nanprod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "max(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-max ::
-    forall args . Fullfilled "max(symbol)" args =>
-      String -> ArgsHMap "max(symbol)" args -> IO SymbolHandle
-max name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "max"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_max(symbol)" = '[]
-
-_backward_max ::
-              forall args . Fullfilled "_backward_max(symbol)" args =>
-                String -> ArgsHMap "_backward_max(symbol)" args -> IO SymbolHandle
-_backward_max name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_max"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "min(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-min ::
-    forall args . Fullfilled "min(symbol)" args =>
-      String -> ArgsHMap "min(symbol)" args -> IO SymbolHandle
-min name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "min"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_min(symbol)" = '[]
-
-_backward_min ::
-              forall args . Fullfilled "_backward_min(symbol)" args =>
-                String -> ArgsHMap "_backward_min(symbol)" args -> IO SymbolHandle
-_backward_min name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_min"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_axis(symbol)" =
-     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-broadcast_axis ::
-               forall args . Fullfilled "broadcast_axis(symbol)" args =>
-                 String -> ArgsHMap "broadcast_axis(symbol)" args -> IO SymbolHandle
-broadcast_axis name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_axis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_to(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-broadcast_to ::
-             forall args . Fullfilled "broadcast_to(symbol)" args =>
-               String -> ArgsHMap "broadcast_to(symbol)" args -> IO SymbolHandle
-broadcast_to name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_to"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_broadcast_backward(symbol)" = '[]
-
-_broadcast_backward ::
-                    forall args . Fullfilled "_broadcast_backward(symbol)" args =>
-                      String ->
-                        ArgsHMap "_broadcast_backward(symbol)" args -> IO SymbolHandle
-_broadcast_backward name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_broadcast_backward"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_like(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_like ::
-               forall args . Fullfilled "broadcast_like(symbol)" args =>
-                 String -> ArgsHMap "broadcast_like(symbol)" args -> IO SymbolHandle
-broadcast_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "norm(symbol)" =
-     '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])),
-        '("keepdims", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-norm ::
-     forall args . Fullfilled "norm(symbol)" args =>
-       String -> ArgsHMap "norm(symbol)" args -> IO SymbolHandle
-norm name args
-  = let scalarArgs
-          = catMaybes
-              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "norm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_norm(symbol)" = '[]
-
-_backward_norm ::
-               forall args . Fullfilled "_backward_norm(symbol)" args =>
-                 String -> ArgsHMap "_backward_norm(symbol)" args -> IO SymbolHandle
-_backward_norm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_norm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_add(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_add ::
-             forall args . Fullfilled "elemwise_add(symbol)" args =>
-               String -> ArgsHMap "elemwise_add(symbol)" args -> IO SymbolHandle
-elemwise_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_grad_add(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_grad_add ::
-          forall args . Fullfilled "_grad_add(symbol)" args =>
-            String -> ArgsHMap "_grad_add(symbol)" args -> IO SymbolHandle
-_grad_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_grad_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_add(symbol)" = '[]
-
-_backward_add ::
-              forall args . Fullfilled "_backward_add(symbol)" args =>
-                String -> ArgsHMap "_backward_add(symbol)" args -> IO SymbolHandle
-_backward_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_sub(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_sub ::
-             forall args . Fullfilled "elemwise_sub(symbol)" args =>
-               String -> ArgsHMap "elemwise_sub(symbol)" args -> IO SymbolHandle
-elemwise_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sub(symbol)" = '[]
-
-_backward_sub ::
-              forall args . Fullfilled "_backward_sub(symbol)" args =>
-                String -> ArgsHMap "_backward_sub(symbol)" args -> IO SymbolHandle
-_backward_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_mul(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_mul ::
-             forall args . Fullfilled "elemwise_mul(symbol)" args =>
-               String -> ArgsHMap "elemwise_mul(symbol)" args -> IO SymbolHandle
-elemwise_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mul(symbol)" = '[]
-
-_backward_mul ::
-              forall args . Fullfilled "_backward_mul(symbol)" args =>
-                String -> ArgsHMap "_backward_mul(symbol)" args -> IO SymbolHandle
-_backward_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_div(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_div ::
-             forall args . Fullfilled "elemwise_div(symbol)" args =>
-               String -> ArgsHMap "elemwise_div(symbol)" args -> IO SymbolHandle
-elemwise_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_div(symbol)" = '[]
-
-_backward_div ::
-              forall args . Fullfilled "_backward_div(symbol)" args =>
-                String -> ArgsHMap "_backward_div(symbol)" args -> IO SymbolHandle
-_backward_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_mod(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_mod ::
-     forall args . Fullfilled "_mod(symbol)" args =>
-       String -> ArgsHMap "_mod(symbol)" args -> IO SymbolHandle
-_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mod(symbol)" = '[]
-
-_backward_mod ::
-              forall args . Fullfilled "_backward_mod(symbol)" args =>
-                String -> ArgsHMap "_backward_mod(symbol)" args -> IO SymbolHandle
-_backward_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_elemwise_div(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_scatter_elemwise_div ::
-                      forall args . Fullfilled "_scatter_elemwise_div(symbol)" args =>
-                        String ->
-                          ArgsHMap "_scatter_elemwise_div(symbol)" args -> IO SymbolHandle
-_scatter_elemwise_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_elemwise_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_plus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_scatter_plus_scalar ::
-                     forall args . Fullfilled "_scatter_plus_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_scatter_plus_scalar(symbol)" args -> IO SymbolHandle
-_scatter_plus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_plus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_minus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_scatter_minus_scalar ::
-                      forall args . Fullfilled "_scatter_minus_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_scatter_minus_scalar(symbol)" args -> IO SymbolHandle
-_scatter_minus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_minus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Embedding(symbol)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle)]
-
-_Embedding ::
-           forall args . Fullfilled "_Embedding(symbol)" args =>
-             String -> ArgsHMap "_Embedding(symbol)" args -> IO SymbolHandle
-_Embedding name args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Embedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_SparseEmbedding(symbol)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle)]
-
-_contrib_SparseEmbedding ::
-                         forall args . Fullfilled "_contrib_SparseEmbedding(symbol)" args =>
-                           String ->
-                             ArgsHMap "_contrib_SparseEmbedding(symbol)" args -> IO SymbolHandle
-_contrib_SparseEmbedding name args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SparseEmbedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Embedding(symbol)" = '[]
-
-_backward_Embedding ::
-                    forall args . Fullfilled "_backward_Embedding(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_Embedding(symbol)" args -> IO SymbolHandle
-_backward_Embedding name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Embedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SparseEmbedding(symbol)" =
-     '[]
-
-_backward_SparseEmbedding ::
-                          forall args .
-                            Fullfilled "_backward_SparseEmbedding(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_SparseEmbedding(symbol)" args ->
-                                IO SymbolHandle
-_backward_SparseEmbedding name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SparseEmbedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "take(symbol)" =
-     '[ '("axis", AttrOpt Int),
-        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),
-        '("a", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)]
-
-take ::
-     forall args . Fullfilled "take(symbol)" args =>
-       String -> ArgsHMap "take(symbol)" args -> IO SymbolHandle
-take name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "take"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_take(symbol)" = '[]
-
-_backward_take ::
-               forall args . Fullfilled "_backward_take(symbol)" args =>
-                 String -> ArgsHMap "_backward_take(symbol)" args -> IO SymbolHandle
-_backward_take name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_take"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "batch_take(symbol)" =
-     '[ '("a", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-batch_take ::
-           forall args . Fullfilled "batch_take(symbol)" args =>
-             String -> ArgsHMap "batch_take(symbol)" args -> IO SymbolHandle
-batch_take name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_take"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "one_hot(symbol)" =
-     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),
-        '("off_value", AttrOpt Double),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("indices", AttrOpt SymbolHandle)]
-
-one_hot ::
-        forall args . Fullfilled "one_hot(symbol)" args =>
-          String -> ArgsHMap "one_hot(symbol)" args -> IO SymbolHandle
-one_hot name args
-  = let scalarArgs
-          = catMaybes
-              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),
-               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),
-               ("off_value",) . showValue <$>
-                 (args !? #off_value :: Maybe Double),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "one_hot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "gather_nd(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-gather_nd ::
-          forall args . Fullfilled "gather_nd(symbol)" args =>
-            String -> ArgsHMap "gather_nd(symbol)" args -> IO SymbolHandle
-gather_nd name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gather_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "scatter_nd(symbol)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-scatter_nd ::
-           forall args . Fullfilled "scatter_nd(symbol)" args =>
-             String -> ArgsHMap "scatter_nd(symbol)" args -> IO SymbolHandle
-scatter_nd name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "scatter_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_gather_nd(symbol)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-_backward_gather_nd ::
-                    forall args . Fullfilled "_backward_gather_nd(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_gather_nd(symbol)" args -> IO SymbolHandle
-_backward_gather_nd name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gather_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_set_nd(symbol)" =
-     '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)]
-
-_scatter_set_nd ::
-                forall args . Fullfilled "_scatter_set_nd(symbol)" args =>
-                  String ->
-                    ArgsHMap "_scatter_set_nd(symbol)" args -> IO SymbolHandle
-_scatter_set_nd name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_set_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_equal ::
-                forall args . Fullfilled "broadcast_equal(symbol)" args =>
-                  String ->
-                    ArgsHMap "broadcast_equal(symbol)" args -> IO SymbolHandle
-broadcast_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_not_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_not_equal ::
-                    forall args . Fullfilled "broadcast_not_equal(symbol)" args =>
-                      String ->
-                        ArgsHMap "broadcast_not_equal(symbol)" args -> IO SymbolHandle
-broadcast_not_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_not_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_greater(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_greater ::
-                  forall args . Fullfilled "broadcast_greater(symbol)" args =>
-                    String ->
-                      ArgsHMap "broadcast_greater(symbol)" args -> IO SymbolHandle
-broadcast_greater name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_greater_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_greater_equal ::
-                        forall args . Fullfilled "broadcast_greater_equal(symbol)" args =>
-                          String ->
-                            ArgsHMap "broadcast_greater_equal(symbol)" args -> IO SymbolHandle
-broadcast_greater_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_lesser(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_lesser ::
-                 forall args . Fullfilled "broadcast_lesser(symbol)" args =>
-                   String ->
-                     ArgsHMap "broadcast_lesser(symbol)" args -> IO SymbolHandle
-broadcast_lesser name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_lesser_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_lesser_equal ::
-                       forall args . Fullfilled "broadcast_lesser_equal(symbol)" args =>
-                         String ->
-                           ArgsHMap "broadcast_lesser_equal(symbol)" args -> IO SymbolHandle
-broadcast_lesser_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_logical_and(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_logical_and ::
-                      forall args . Fullfilled "broadcast_logical_and(symbol)" args =>
-                        String ->
-                          ArgsHMap "broadcast_logical_and(symbol)" args -> IO SymbolHandle
-broadcast_logical_and name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_and"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_logical_or(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_logical_or ::
-                     forall args . Fullfilled "broadcast_logical_or(symbol)" args =>
-                       String ->
-                         ArgsHMap "broadcast_logical_or(symbol)" args -> IO SymbolHandle
-broadcast_logical_or name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_or"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_logical_xor(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_logical_xor ::
-                      forall args . Fullfilled "broadcast_logical_xor(symbol)" args =>
-                        String ->
-                          ArgsHMap "broadcast_logical_xor(symbol)" args -> IO SymbolHandle
-broadcast_logical_xor name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_xor"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_plus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_plus_scalar ::
-             forall args . Fullfilled "_plus_scalar(symbol)" args =>
-               String -> ArgsHMap "_plus_scalar(symbol)" args -> IO SymbolHandle
-_plus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_plus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_minus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_minus_scalar ::
-              forall args . Fullfilled "_minus_scalar(symbol)" args =>
-                String -> ArgsHMap "_minus_scalar(symbol)" args -> IO SymbolHandle
-_minus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rminus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rminus_scalar ::
-               forall args . Fullfilled "_rminus_scalar(symbol)" args =>
-                 String -> ArgsHMap "_rminus_scalar(symbol)" args -> IO SymbolHandle
-_rminus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rminus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_mul_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_mul_scalar ::
-            forall args . Fullfilled "_mul_scalar(symbol)" args =>
-              String -> ArgsHMap "_mul_scalar(symbol)" args -> IO SymbolHandle
-_mul_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mul_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mul_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_backward_mul_scalar ::
-                     forall args . Fullfilled "_backward_mul_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_mul_scalar(symbol)" args -> IO SymbolHandle
-_backward_mul_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_div_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_div_scalar ::
-            forall args . Fullfilled "_div_scalar(symbol)" args =>
-              String -> ArgsHMap "_div_scalar(symbol)" args -> IO SymbolHandle
-_div_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_div_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_div_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_backward_div_scalar ::
-                     forall args . Fullfilled "_backward_div_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_div_scalar(symbol)" args -> IO SymbolHandle
-_backward_div_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rdiv_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rdiv_scalar ::
-             forall args . Fullfilled "_rdiv_scalar(symbol)" args =>
-               String -> ArgsHMap "_rdiv_scalar(symbol)" args -> IO SymbolHandle
-_rdiv_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rdiv_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rdiv_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rdiv_scalar ::
-                      forall args . Fullfilled "_backward_rdiv_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_rdiv_scalar(symbol)" args -> IO SymbolHandle
-_backward_rdiv_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rdiv_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_mod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_mod_scalar ::
-            forall args . Fullfilled "_mod_scalar(symbol)" args =>
-              String -> ArgsHMap "_mod_scalar(symbol)" args -> IO SymbolHandle
-_mod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_mod_scalar ::
-                     forall args . Fullfilled "_backward_mod_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_mod_scalar(symbol)" args -> IO SymbolHandle
-_backward_mod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rmod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rmod_scalar ::
-             forall args . Fullfilled "_rmod_scalar(symbol)" args =>
-               String -> ArgsHMap "_rmod_scalar(symbol)" args -> IO SymbolHandle
-_rmod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rmod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rmod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rmod_scalar ::
-                      forall args . Fullfilled "_backward_rmod_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_rmod_scalar(symbol)" args -> IO SymbolHandle
-_backward_rmod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rmod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_ravel_multi_index(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-_ravel_multi_index ::
-                   forall args . Fullfilled "_ravel_multi_index(symbol)" args =>
-                     String ->
-                       ArgsHMap "_ravel_multi_index(symbol)" args -> IO SymbolHandle
-_ravel_multi_index name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ravel_multi_index"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_unravel_index(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-_unravel_index ::
-               forall args . Fullfilled "_unravel_index(symbol)" args =>
-                 String -> ArgsHMap "_unravel_index(symbol)" args -> IO SymbolHandle
-_unravel_index name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_unravel_index"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argmax(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-argmax ::
-       forall args . Fullfilled "argmax(symbol)" args =>
-         String -> ArgsHMap "argmax(symbol)" args -> IO SymbolHandle
-argmax name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argmin(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-argmin ::
-       forall args . Fullfilled "argmin(symbol)" args =>
-         String -> ArgsHMap "argmin(symbol)" args -> IO SymbolHandle
-argmin name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argmax_channel(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-argmax_channel ::
-               forall args . Fullfilled "argmax_channel(symbol)" args =>
-                 String -> ArgsHMap "argmax_channel(symbol)" args -> IO SymbolHandle
-argmax_channel name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax_channel"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "pick(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("mode", AttrOpt (EnumType '["clip", "wrap"])),
-        '("data", AttrOpt SymbolHandle), '("index", AttrOpt SymbolHandle)]
-
-pick ::
-     forall args . Fullfilled "pick(symbol)" args =>
-       String -> ArgsHMap "pick(symbol)" args -> IO SymbolHandle
-pick name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("index",) <$> (args !? #index :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "pick"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_pick(symbol)" = '[]
-
-_backward_pick ::
-               forall args . Fullfilled "_backward_pick(symbol)" args =>
-                 String -> ArgsHMap "_backward_pick(symbol)" args -> IO SymbolHandle
-_backward_pick name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_pick"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sparse_retain(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-_sparse_retain ::
-               forall args . Fullfilled "_sparse_retain(symbol)" args =>
-                 String -> ArgsHMap "_sparse_retain(symbol)" args -> IO SymbolHandle
-_sparse_retain name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_retain"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sparse_retain(symbol)" = '[]
-
-_backward_sparse_retain ::
-                        forall args . Fullfilled "_backward_sparse_retain(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_sparse_retain(symbol)" args -> IO SymbolHandle
-_backward_sparse_retain name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sparse_retain"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_where(symbol)" =
-     '[ '("condition", AttrOpt SymbolHandle),
-        '("x", AttrOpt SymbolHandle), '("y", AttrOpt SymbolHandle)]
-
-_where ::
-       forall args . Fullfilled "_where(symbol)" args =>
-         String -> ArgsHMap "_where(symbol)" args -> IO SymbolHandle
-_where name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("condition",) <$> (args !? #condition :: Maybe SymbolHandle),
-               ("x",) <$> (args !? #x :: Maybe SymbolHandle),
-               ("y",) <$> (args !? #y :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "where"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_where(symbol)" = '[]
-
-_backward_where ::
-                forall args . Fullfilled "_backward_where(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_where(symbol)" args -> IO SymbolHandle
-_backward_where name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_where"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "diag(symbol)" =
-     '[ '("k", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)]
-
-diag ::
-     forall args . Fullfilled "diag(symbol)" args =>
-       String -> ArgsHMap "diag(symbol)" args -> IO SymbolHandle
-diag name args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe (Maybe Int))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "diag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_diag(symbol)" = '[]
-
-_backward_diag ::
-               forall args . Fullfilled "_backward_diag(symbol)" args =>
-                 String -> ArgsHMap "_backward_diag(symbol)" args -> IO SymbolHandle
-_backward_diag name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_diag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_maximum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_maximum_scalar ::
-                forall args . Fullfilled "_maximum_scalar(symbol)" args =>
-                  String ->
-                    ArgsHMap "_maximum_scalar(symbol)" args -> IO SymbolHandle
-_maximum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_maximum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_maximum_scalar ::
-                         forall args . Fullfilled "_backward_maximum_scalar(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_maximum_scalar(symbol)" args -> IO SymbolHandle
-_backward_maximum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_minimum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_minimum_scalar ::
-                forall args . Fullfilled "_minimum_scalar(symbol)" args =>
-                  String ->
-                    ArgsHMap "_minimum_scalar(symbol)" args -> IO SymbolHandle
-_minimum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_minimum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_minimum_scalar ::
-                         forall args . Fullfilled "_backward_minimum_scalar(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_minimum_scalar(symbol)" args -> IO SymbolHandle
-_backward_minimum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_power_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_power_scalar ::
-              forall args . Fullfilled "_power_scalar(symbol)" args =>
-                String -> ArgsHMap "_power_scalar(symbol)" args -> IO SymbolHandle
-_power_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_power_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_power_scalar ::
-                       forall args . Fullfilled "_backward_power_scalar(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_power_scalar(symbol)" args -> IO SymbolHandle
-_backward_power_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rpower_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rpower_scalar ::
-               forall args . Fullfilled "_rpower_scalar(symbol)" args =>
-                 String -> ArgsHMap "_rpower_scalar(symbol)" args -> IO SymbolHandle
-_rpower_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rpower_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rpower_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rpower_scalar ::
-                        forall args . Fullfilled "_backward_rpower_scalar(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_rpower_scalar(symbol)" args -> IO SymbolHandle
-_backward_rpower_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rpower_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_hypot_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_hypot_scalar ::
-              forall args . Fullfilled "_hypot_scalar(symbol)" args =>
-                String -> ArgsHMap "_hypot_scalar(symbol)" args -> IO SymbolHandle
-_hypot_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_hypot_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_hypot_scalar ::
-                       forall args . Fullfilled "_backward_hypot_scalar(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_hypot_scalar(symbol)" args -> IO SymbolHandle
-_backward_hypot_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "smooth_l1(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-smooth_l1 ::
-          forall args . Fullfilled "smooth_l1(symbol)" args =>
-            String -> ArgsHMap "smooth_l1(symbol)" args -> IO SymbolHandle
-smooth_l1 name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "smooth_l1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_smooth_l1(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_smooth_l1 ::
-                    forall args . Fullfilled "_backward_smooth_l1(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_smooth_l1(symbol)" args -> IO SymbolHandle
-_backward_smooth_l1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_smooth_l1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "topk(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),
-        '("ret_typ",
-          AttrOpt (EnumType '["both", "indices", "mask", "value"])),
-        '("is_ascend", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt SymbolHandle)]
-
-topk ::
-     forall args . Fullfilled "topk(symbol)" args =>
-       String -> ArgsHMap "topk(symbol)" args -> IO SymbolHandle
-topk name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ret_typ",) . showValue <$>
-                 (args !? #ret_typ ::
-                    Maybe (EnumType '["both", "indices", "mask", "value"])),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "topk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_topk(symbol)" = '[]
-
-_backward_topk ::
-               forall args . Fullfilled "_backward_topk(symbol)" args =>
-                 String -> ArgsHMap "_backward_topk(symbol)" args -> IO SymbolHandle
-_backward_topk name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_topk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sort(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-sort ::
-     forall args . Fullfilled "sort(symbol)" args =>
-       String -> ArgsHMap "sort(symbol)" args -> IO SymbolHandle
-sort name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sort"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argsort(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt SymbolHandle)]
-
-argsort ::
-        forall args . Fullfilled "argsort(symbol)" args =>
-          String -> ArgsHMap "argsort(symbol)" args -> IO SymbolHandle
-argsort name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argsort"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Reshape(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),
-        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-_Reshape ::
-         forall args . Fullfilled "_Reshape(symbol)" args =>
-           String -> ArgsHMap "_Reshape(symbol)" args -> IO SymbolHandle
-_Reshape name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("keep_highest",) . showValue <$>
-                 (args !? #keep_highest :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Reshape"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Flatten(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_Flatten ::
-         forall args . Fullfilled "_Flatten(symbol)" args =>
-           String -> ArgsHMap "_Flatten(symbol)" args -> IO SymbolHandle
-_Flatten name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Flatten"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "transpose(symbol)" =
-     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-transpose ::
-          forall args . Fullfilled "transpose(symbol)" args =>
-            String -> ArgsHMap "transpose(symbol)" args -> IO SymbolHandle
-transpose name args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "transpose"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "expand_dims(symbol)" =
-     '[ '("axis", AttrReq Int), '("data", AttrOpt SymbolHandle)]
-
-expand_dims ::
-            forall args . Fullfilled "expand_dims(symbol)" args =>
-              String -> ArgsHMap "expand_dims(symbol)" args -> IO SymbolHandle
-expand_dims name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expand_dims"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "slice(symbol)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-slice ::
-      forall args . Fullfilled "slice(symbol)" args =>
-        String -> ArgsHMap "slice(symbol)" args -> IO SymbolHandle
-slice name args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_slice(symbol)" = '[]
-
-_backward_slice ::
-                forall args . Fullfilled "_backward_slice(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_slice(symbol)" args -> IO SymbolHandle
-_backward_slice name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_slice_assign(symbol)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_slice_assign ::
-              forall args . Fullfilled "_slice_assign(symbol)" args =>
-                String -> ArgsHMap "_slice_assign(symbol)" args -> IO SymbolHandle
-_slice_assign name args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_slice_assign_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("begin", AttrReq [Int]),
-        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-_slice_assign_scalar ::
-                     forall args . Fullfilled "_slice_assign_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_slice_assign_scalar(symbol)" args -> IO SymbolHandle
-_slice_assign_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "slice_axis(symbol)" =
-     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),
-        '("end", AttrReq (Maybe Int)), '("data", AttrOpt SymbolHandle)]
-
-slice_axis ::
-           forall args . Fullfilled "slice_axis(symbol)" args =>
-             String -> ArgsHMap "slice_axis(symbol)" args -> IO SymbolHandle
-slice_axis name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),
-               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_axis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_slice_axis(symbol)" = '[]
-
-_backward_slice_axis ::
-                     forall args . Fullfilled "_backward_slice_axis(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_slice_axis(symbol)" args -> IO SymbolHandle
-_backward_slice_axis name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_axis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "slice_like(symbol)" =
-     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle),
-        '("shape_like", AttrOpt SymbolHandle)]
-
-slice_like ::
-           forall args . Fullfilled "slice_like(symbol)" args =>
-             String -> ArgsHMap "slice_like(symbol)" args -> IO SymbolHandle
-slice_like name args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("shape_like",) <$> (args !? #shape_like :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_slice_like(symbol)" = '[]
-
-_backward_slice_like ::
-                     forall args . Fullfilled "_backward_slice_like(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_slice_like(symbol)" args -> IO SymbolHandle
-_backward_slice_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "clip(symbol)" =
-     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-clip ::
-     forall args . Fullfilled "clip(symbol)" args =>
-       String -> ArgsHMap "clip(symbol)" args -> IO SymbolHandle
-clip name args
-  = let scalarArgs
-          = catMaybes
-              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),
-               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "clip"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_clip(symbol)" = '[]
-
-_backward_clip ::
-               forall args . Fullfilled "_backward_clip(symbol)" args =>
-                 String -> ArgsHMap "_backward_clip(symbol)" args -> IO SymbolHandle
-_backward_clip name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_clip"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "repeat(symbol)" =
-     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),
-        '("data", AttrOpt SymbolHandle)]
-
-repeat ::
-       forall args . Fullfilled "repeat(symbol)" args =>
-         String -> ArgsHMap "repeat(symbol)" args -> IO SymbolHandle
-repeat name args
-  = let scalarArgs
-          = catMaybes
-              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "repeat"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_repeat(symbol)" = '[]
-
-_backward_repeat ::
-                 forall args . Fullfilled "_backward_repeat(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_repeat(symbol)" args -> IO SymbolHandle
-_backward_repeat name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_repeat"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "tile(symbol)" =
-     '[ '("reps", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]
-
-tile ::
-     forall args . Fullfilled "tile(symbol)" args =>
-       String -> ArgsHMap "tile(symbol)" args -> IO SymbolHandle
-tile name args
-  = let scalarArgs
-          = catMaybes
-              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tile"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_tile(symbol)" = '[]
-
-_backward_tile ::
-               forall args . Fullfilled "_backward_tile(symbol)" args =>
-                 String -> ArgsHMap "_backward_tile(symbol)" args -> IO SymbolHandle
-_backward_tile name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tile"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "reverse(symbol)" =
-     '[ '("axis", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]
-
-reverse ::
-        forall args . Fullfilled "reverse(symbol)" args =>
-          String -> ArgsHMap "reverse(symbol)" args -> IO SymbolHandle
-reverse name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_reverse(symbol)" = '[]
-
-_backward_reverse ::
-                  forall args . Fullfilled "_backward_reverse(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_reverse(symbol)" args -> IO SymbolHandle
-_backward_reverse name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "stack(symbol)" =
-     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-stack ::
-      forall args . Fullfilled "stack(symbol)" args =>
-        String -> ArgsHMap "stack(symbol)" args -> IO SymbolHandle
-stack name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "stack"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_stack(symbol)" = '[]
-
-_backward_stack ::
-                forall args . Fullfilled "_backward_stack(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_stack(symbol)" args -> IO SymbolHandle
-_backward_stack name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_stack"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "squeeze(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])),
-        '("data", AttrOpt [SymbolHandle])]
-
-squeeze ::
-        forall args . Fullfilled "squeeze(symbol)" args =>
-          String -> ArgsHMap "squeeze(symbol)" args -> IO SymbolHandle
-squeeze name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "squeeze"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_squeeze(symbol)" = '[]
-
-_backward_squeeze ::
-                  forall args . Fullfilled "_backward_squeeze(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_squeeze(symbol)" args -> IO SymbolHandle
-_backward_squeeze name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_squeeze"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "depth_to_space(symbol)" =
-     '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)]
-
-depth_to_space ::
-               forall args . Fullfilled "depth_to_space(symbol)" args =>
-                 String -> ArgsHMap "depth_to_space(symbol)" args -> IO SymbolHandle
-depth_to_space name args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "depth_to_space"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "space_to_depth(symbol)" =
-     '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)]
-
-space_to_depth ::
-               forall args . Fullfilled "space_to_depth(symbol)" args =>
-                 String -> ArgsHMap "space_to_depth(symbol)" args -> IO SymbolHandle
-space_to_depth name args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "space_to_depth"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "dot(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),
-        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-dot ::
-    forall args . Fullfilled "dot(symbol)" args =>
-      String -> ArgsHMap "dot(symbol)" args -> IO SymbolHandle
-dot name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_dot(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-
-_backward_dot ::
-              forall args . Fullfilled "_backward_dot(symbol)" args =>
-                String -> ArgsHMap "_backward_dot(symbol)" args -> IO SymbolHandle
-_backward_dot name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "batch_dot(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),
-        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-batch_dot ::
-          forall args . Fullfilled "batch_dot(symbol)" args =>
-            String -> ArgsHMap "batch_dot(symbol)" args -> IO SymbolHandle
-batch_dot name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_batch_dot(symbol)" = '[]
-
-_backward_batch_dot ::
-                    forall args . Fullfilled "_backward_batch_dot(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_batch_dot(symbol)" args -> IO SymbolHandle
-_backward_batch_dot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_batch_dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sin(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sin ::
-    forall args . Fullfilled "sin(symbol)" args =>
-      String -> ArgsHMap "sin(symbol)" args -> IO SymbolHandle
-sin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sin(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sin ::
-              forall args . Fullfilled "_backward_sin(symbol)" args =>
-                String -> ArgsHMap "_backward_sin(symbol)" args -> IO SymbolHandle
-_backward_sin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cos(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-cos ::
-    forall args . Fullfilled "cos(symbol)" args =>
-      String -> ArgsHMap "cos(symbol)" args -> IO SymbolHandle
-cos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cos(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_cos ::
-              forall args . Fullfilled "_backward_cos(symbol)" args =>
-                String -> ArgsHMap "_backward_cos(symbol)" args -> IO SymbolHandle
-_backward_cos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "tan(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-tan ::
-    forall args . Fullfilled "tan(symbol)" args =>
-      String -> ArgsHMap "tan(symbol)" args -> IO SymbolHandle
-tan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_tan(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_tan ::
-              forall args . Fullfilled "_backward_tan(symbol)" args =>
-                String -> ArgsHMap "_backward_tan(symbol)" args -> IO SymbolHandle
-_backward_tan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arcsin(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arcsin ::
-       forall args . Fullfilled "arcsin(symbol)" args =>
-         String -> ArgsHMap "arcsin(symbol)" args -> IO SymbolHandle
-arcsin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arcsin(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arcsin ::
-                 forall args . Fullfilled "_backward_arcsin(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_arcsin(symbol)" args -> IO SymbolHandle
-_backward_arcsin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arccos(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arccos ::
-       forall args . Fullfilled "arccos(symbol)" args =>
-         String -> ArgsHMap "arccos(symbol)" args -> IO SymbolHandle
-arccos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arccos(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arccos ::
-                 forall args . Fullfilled "_backward_arccos(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_arccos(symbol)" args -> IO SymbolHandle
-_backward_arccos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arctan(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arctan ::
-       forall args . Fullfilled "arctan(symbol)" args =>
-         String -> ArgsHMap "arctan(symbol)" args -> IO SymbolHandle
-arctan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arctan(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arctan ::
-                 forall args . Fullfilled "_backward_arctan(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_arctan(symbol)" args -> IO SymbolHandle
-_backward_arctan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "degrees(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-degrees ::
-        forall args . Fullfilled "degrees(symbol)" args =>
-          String -> ArgsHMap "degrees(symbol)" args -> IO SymbolHandle
-degrees name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "degrees"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_degrees(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_degrees ::
-                  forall args . Fullfilled "_backward_degrees(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_degrees(symbol)" args -> IO SymbolHandle
-_backward_degrees name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_degrees"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "radians(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-radians ::
-        forall args . Fullfilled "radians(symbol)" args =>
-          String -> ArgsHMap "radians(symbol)" args -> IO SymbolHandle
-radians name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "radians"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_radians(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_radians ::
-                  forall args . Fullfilled "_backward_radians(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_radians(symbol)" args -> IO SymbolHandle
-_backward_radians name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_radians"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sinh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sinh ::
-     forall args . Fullfilled "sinh(symbol)" args =>
-       String -> ArgsHMap "sinh(symbol)" args -> IO SymbolHandle
-sinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sinh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sinh ::
-               forall args . Fullfilled "_backward_sinh(symbol)" args =>
-                 String -> ArgsHMap "_backward_sinh(symbol)" args -> IO SymbolHandle
-_backward_sinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cosh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-cosh ::
-     forall args . Fullfilled "cosh(symbol)" args =>
-       String -> ArgsHMap "cosh(symbol)" args -> IO SymbolHandle
-cosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cosh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_cosh ::
-               forall args . Fullfilled "_backward_cosh(symbol)" args =>
-                 String -> ArgsHMap "_backward_cosh(symbol)" args -> IO SymbolHandle
-_backward_cosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "tanh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-tanh ::
-     forall args . Fullfilled "tanh(symbol)" args =>
-       String -> ArgsHMap "tanh(symbol)" args -> IO SymbolHandle
-tanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_tanh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_tanh ::
-               forall args . Fullfilled "_backward_tanh(symbol)" args =>
-                 String -> ArgsHMap "_backward_tanh(symbol)" args -> IO SymbolHandle
-_backward_tanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arcsinh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arcsinh ::
-        forall args . Fullfilled "arcsinh(symbol)" args =>
-          String -> ArgsHMap "arcsinh(symbol)" args -> IO SymbolHandle
-arcsinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arcsinh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arcsinh ::
-                  forall args . Fullfilled "_backward_arcsinh(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_arcsinh(symbol)" args -> IO SymbolHandle
-_backward_arcsinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arccosh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arccosh ::
-        forall args . Fullfilled "arccosh(symbol)" args =>
-          String -> ArgsHMap "arccosh(symbol)" args -> IO SymbolHandle
-arccosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arccosh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arccosh ::
-                  forall args . Fullfilled "_backward_arccosh(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_arccosh(symbol)" args -> IO SymbolHandle
-_backward_arccosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arctanh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arctanh ::
-        forall args . Fullfilled "arctanh(symbol)" args =>
-          String -> ArgsHMap "arctanh(symbol)" args -> IO SymbolHandle
-arctanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arctanh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arctanh ::
-                  forall args . Fullfilled "_backward_arctanh(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_arctanh(symbol)" args -> IO SymbolHandle
-_backward_arctanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_CTCLoss(symbol)" =
-     '[ '("use_data_lengths", AttrOpt Bool),
-        '("use_label_lengths", AttrOpt Bool),
-        '("blank_label", AttrOpt (EnumType '["first", "last"])),
-        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle),
-        '("data_lengths", AttrOpt SymbolHandle),
-        '("label_lengths", AttrOpt SymbolHandle)]
-
-_contrib_CTCLoss ::
-                 forall args . Fullfilled "_contrib_CTCLoss(symbol)" args =>
-                   String ->
-                     ArgsHMap "_contrib_CTCLoss(symbol)" args -> IO SymbolHandle
-_contrib_CTCLoss name args
-  = let scalarArgs
-          = catMaybes
-              [("use_data_lengths",) . showValue <$>
-                 (args !? #use_data_lengths :: Maybe Bool),
-               ("use_label_lengths",) . showValue <$>
-                 (args !? #use_label_lengths :: Maybe Bool),
-               ("blank_label",) . showValue <$>
-                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle),
-               ("data_lengths",) <$>
-                 (args !? #data_lengths :: Maybe SymbolHandle),
-               ("label_lengths",) <$>
-                 (args !? #label_lengths :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_CTCLoss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quadratic(symbol)" =
-     '[ '("a", AttrOpt Float), '("b", AttrOpt Float),
-        '("c", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_contrib_quadratic ::
-                   forall args . Fullfilled "_contrib_quadratic(symbol)" args =>
-                     String ->
-                       ArgsHMap "_contrib_quadratic(symbol)" args -> IO SymbolHandle
-_contrib_quadratic name args
-  = let scalarArgs
-          = catMaybes
-              [("a",) . showValue <$> (args !? #a :: Maybe Float),
-               ("b",) . showValue <$> (args !? #b :: Maybe Float),
-               ("c",) . showValue <$> (args !? #c :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quadratic"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_backward_quadratic(symbol)" =
-     '[]
-
-_contrib_backward_quadratic ::
-                            forall args .
-                              Fullfilled "_contrib_backward_quadratic(symbol)" args =>
-                              String ->
-                                ArgsHMap "_contrib_backward_quadratic(symbol)" args ->
-                                  IO SymbolHandle
-_contrib_backward_quadratic name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_quadratic"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_div_sqrt_dim(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_contrib_div_sqrt_dim ::
-                      forall args . Fullfilled "_contrib_div_sqrt_dim(symbol)" args =>
-                        String ->
-                          ArgsHMap "_contrib_div_sqrt_dim(symbol)" args -> IO SymbolHandle
-_contrib_div_sqrt_dim name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "khatri_rao(symbol)" =
-     '[ '("args", AttrOpt [SymbolHandle])]
-
-khatri_rao ::
-           forall args . Fullfilled "khatri_rao(symbol)" args =>
-             String -> ArgsHMap "khatri_rao(symbol)" args -> IO SymbolHandle
-khatri_rao name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "khatri_rao"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_contrib_ROIAlign(symbol)" =
-     '[ '("pooled_size", AttrReq [Int]),
-        '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)]
-
-_contrib_ROIAlign ::
-                  forall args . Fullfilled "_contrib_ROIAlign(symbol)" args =>
-                    String ->
-                      ArgsHMap "_contrib_ROIAlign(symbol)" args -> IO SymbolHandle
-_contrib_ROIAlign name args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("sample_ratio",) . showValue <$>
-                 (args !? #sample_ratio :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ROIAlign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_ROIAlign(symbol)" = '[]
-
-_backward_ROIAlign ::
-                   forall args . Fullfilled "_backward_ROIAlign(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_ROIAlign(symbol)" args -> IO SymbolHandle
-_backward_ROIAlign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIAlign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_box_nms(symbol)" =
-     '[ '("overlap_thresh", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),
-        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),
-        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),
-        '("in_format", AttrOpt (EnumType '["center", "corner"])),
-        '("out_format", AttrOpt (EnumType '["center", "corner"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_contrib_box_nms ::
-                 forall args . Fullfilled "_contrib_box_nms(symbol)" args =>
-                   String ->
-                     ArgsHMap "_contrib_box_nms(symbol)" args -> IO SymbolHandle
-_contrib_box_nms name args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_nms"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_contrib_box_nms(symbol)" =
-     '[ '("overlap_thresh", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),
-        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),
-        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),
-        '("in_format", AttrOpt (EnumType '["center", "corner"])),
-        '("out_format", AttrOpt (EnumType '["center", "corner"]))]
-
-_backward_contrib_box_nms ::
-                          forall args .
-                            Fullfilled "_backward_contrib_box_nms(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_contrib_box_nms(symbol)" args ->
-                                IO SymbolHandle
-_backward_contrib_box_nms name args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_nms"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_box_iou(symbol)" =
-     '[ '("format", AttrOpt (EnumType '["center", "corner"])),
-        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_contrib_box_iou ::
-                 forall args . Fullfilled "_contrib_box_iou(symbol)" args =>
-                   String ->
-                     ArgsHMap "_contrib_box_iou(symbol)" args -> IO SymbolHandle
-_contrib_box_iou name args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_iou"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_contrib_box_iou(symbol)" =
-     '[ '("format", AttrOpt (EnumType '["center", "corner"]))]
-
-_backward_contrib_box_iou ::
-                          forall args .
-                            Fullfilled "_backward_contrib_box_iou(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_contrib_box_iou(symbol)" args ->
-                                IO SymbolHandle
-_backward_contrib_box_iou name args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_iou"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_bipartite_matching(symbol)" =
-     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),
-        '("topk", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-_contrib_bipartite_matching ::
-                            forall args .
-                              Fullfilled "_contrib_bipartite_matching(symbol)" args =>
-                              String ->
-                                ArgsHMap "_contrib_bipartite_matching(symbol)" args ->
-                                  IO SymbolHandle
-_contrib_bipartite_matching name args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_bipartite_matching"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_contrib_bipartite_matching(symbol)" =
-     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),
-        '("topk", AttrOpt Int)]
-
-_backward_contrib_bipartite_matching ::
-                                     forall args .
-                                       Fullfilled "_backward_contrib_bipartite_matching(symbol)"
-                                         args =>
-                                       String ->
-                                         ArgsHMap "_backward_contrib_bipartite_matching(symbol)"
-                                           args
-                                           -> IO SymbolHandle
-_backward_contrib_bipartite_matching name args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_BilinearResize2D(symbol)" =
-     '[ '("height", AttrReq Int), '("width", AttrReq Int),
-        '("data", AttrOpt SymbolHandle)]
-
-_contrib_BilinearResize2D ::
-                          forall args .
-                            Fullfilled "_contrib_BilinearResize2D(symbol)" args =>
-                            String ->
-                              ArgsHMap "_contrib_BilinearResize2D(symbol)" args ->
-                                IO SymbolHandle
-_contrib_BilinearResize2D name args
-  = let scalarArgs
-          = catMaybes
-              [("height",) . showValue <$> (args !? #height :: Maybe Int),
-               ("width",) . showValue <$> (args !? #width :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_BilinearResize2D"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_contrib_BilinearResize2D(symbol)" = '[]
-
-_backward_contrib_BilinearResize2D ::
-                                   forall args .
-                                     Fullfilled "_backward_contrib_BilinearResize2D(symbol)" args =>
-                                     String ->
-                                       ArgsHMap "_backward_contrib_BilinearResize2D(symbol)" args ->
-                                         IO SymbolHandle
-_backward_contrib_BilinearResize2D name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_SyncBatchNorm(symbol)" =
-     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int),
-        '("key", AttrOpt String), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),
-        '("moving_mean", AttrOpt SymbolHandle),
-        '("moving_var", AttrOpt SymbolHandle)]
-
-_contrib_SyncBatchNorm ::
-                       forall args . Fullfilled "_contrib_SyncBatchNorm(symbol)" args =>
-                         String ->
-                           ArgsHMap "_contrib_SyncBatchNorm(symbol)" args -> IO SymbolHandle
-_contrib_SyncBatchNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),
-               ("key",) . showValue <$> (args !? #key :: Maybe String)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_AdaptiveAvgPooling2D(symbol)"
-     =
-     '[ '("output_size", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-_contrib_AdaptiveAvgPooling2D ::
-                              forall args .
-                                Fullfilled "_contrib_AdaptiveAvgPooling2D(symbol)" args =>
-                                String ->
-                                  ArgsHMap "_contrib_AdaptiveAvgPooling2D(symbol)" args ->
-                                    IO SymbolHandle
-_contrib_AdaptiveAvgPooling2D name args
-  = let scalarArgs
-          = catMaybes
-              [("output_size",) . showValue <$>
-                 (args !? #output_size :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_contrib_AdaptiveAvgPooling2D(symbol)" =
-     '[]
-
-_backward_contrib_AdaptiveAvgPooling2D ::
-                                       forall args .
-                                         Fullfilled "_backward_contrib_AdaptiveAvgPooling2D(symbol)"
-                                           args =>
-                                         String ->
-                                           ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(symbol)"
-                                             args
-                                             -> IO SymbolHandle
-_backward_contrib_AdaptiveAvgPooling2D name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_to_tensor(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_image_to_tensor ::
-                 forall args . Fullfilled "_image_to_tensor(symbol)" args =>
-                   String ->
-                     ArgsHMap "_image_to_tensor(symbol)" args -> IO SymbolHandle
-_image_to_tensor name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_to_tensor"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_normalize(symbol)" =
-     '[ '("mean", AttrReq [Float]), '("std", AttrReq [Float]),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_normalize ::
-                 forall args . Fullfilled "_image_normalize(symbol)" args =>
-                   String ->
-                     ArgsHMap "_image_normalize(symbol)" args -> IO SymbolHandle
-_image_normalize name args
-  = let scalarArgs
-          = catMaybes
-              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),
-               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_normalize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_flip_left_right(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_image_flip_left_right ::
-                       forall args . Fullfilled "_image_flip_left_right(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_flip_left_right(symbol)" args -> IO SymbolHandle
-_image_flip_left_right name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_left_right"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_flip_left_right(symbol)"
-     = '[ '("data", AttrOpt SymbolHandle)]
-
-_image_random_flip_left_right ::
-                              forall args .
-                                Fullfilled "_image_random_flip_left_right(symbol)" args =>
-                                String ->
-                                  ArgsHMap "_image_random_flip_left_right(symbol)" args ->
-                                    IO SymbolHandle
-_image_random_flip_left_right name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_left_right"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_flip_top_bottom(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_image_flip_top_bottom ::
-                       forall args . Fullfilled "_image_flip_top_bottom(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_flip_top_bottom(symbol)" args -> IO SymbolHandle
-_image_flip_top_bottom name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_top_bottom"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_flip_top_bottom(symbol)"
-     = '[ '("data", AttrOpt SymbolHandle)]
-
-_image_random_flip_top_bottom ::
-                              forall args .
-                                Fullfilled "_image_random_flip_top_bottom(symbol)" args =>
-                                String ->
-                                  ArgsHMap "_image_random_flip_top_bottom(symbol)" args ->
-                                    IO SymbolHandle
-_image_random_flip_top_bottom name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_top_bottom"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_brightness(symbol)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_brightness ::
-                         forall args . Fullfilled "_image_random_brightness(symbol)" args =>
-                           String ->
-                             ArgsHMap "_image_random_brightness(symbol)" args -> IO SymbolHandle
-_image_random_brightness name args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_brightness"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_contrast(symbol)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_contrast ::
-                       forall args . Fullfilled "_image_random_contrast(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_random_contrast(symbol)" args -> IO SymbolHandle
-_image_random_contrast name args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_contrast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_saturation(symbol)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_saturation ::
-                         forall args . Fullfilled "_image_random_saturation(symbol)" args =>
-                           String ->
-                             ArgsHMap "_image_random_saturation(symbol)" args -> IO SymbolHandle
-_image_random_saturation name args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_saturation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_hue(symbol)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_hue ::
-                  forall args . Fullfilled "_image_random_hue(symbol)" args =>
-                    String ->
-                      ArgsHMap "_image_random_hue(symbol)" args -> IO SymbolHandle
-_image_random_hue name args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_hue"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_color_jitter(symbol)" =
-     '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float),
-        '("saturation", AttrReq Float), '("hue", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_color_jitter ::
-                           forall args .
-                             Fullfilled "_image_random_color_jitter(symbol)" args =>
-                             String ->
-                               ArgsHMap "_image_random_color_jitter(symbol)" args ->
-                                 IO SymbolHandle
-_image_random_color_jitter name args
-  = let scalarArgs
-          = catMaybes
-              [("brightness",) . showValue <$>
-                 (args !? #brightness :: Maybe Float),
-               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
-               ("saturation",) . showValue <$>
-                 (args !? #saturation :: Maybe Float),
-               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_color_jitter"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_adjust_lighting(symbol)" =
-     '[ '("alpha", AttrReq [Float]), '("data", AttrOpt SymbolHandle)]
-
-_image_adjust_lighting ::
-                       forall args . Fullfilled "_image_adjust_lighting(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_adjust_lighting(symbol)" args -> IO SymbolHandle
-_image_adjust_lighting name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_adjust_lighting"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_lighting(symbol)" =
-     '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_image_random_lighting ::
-                       forall args . Fullfilled "_image_random_lighting(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_random_lighting(symbol)" args -> IO SymbolHandle
-_image_random_lighting name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha_std",) . showValue <$>
-                 (args !? #alpha_std :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_lighting"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "softmax(symbol)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("data", AttrOpt SymbolHandle)]
-
-softmax ::
-        forall args . Fullfilled "softmax(symbol)" args =>
-          String -> ArgsHMap "softmax(symbol)" args -> IO SymbolHandle
-softmax name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_softmax(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_softmax ::
-                  forall args . Fullfilled "_backward_softmax(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_softmax(symbol)" args -> IO SymbolHandle
-_backward_softmax name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log_softmax(symbol)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("data", AttrOpt SymbolHandle)]
-
-log_softmax ::
-            forall args . Fullfilled "log_softmax(symbol)" args =>
-              String -> ArgsHMap "log_softmax(symbol)" args -> IO SymbolHandle
-log_softmax name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log_softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log_softmax(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log_softmax ::
-                      forall args . Fullfilled "_backward_log_softmax(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_log_softmax(symbol)" args -> IO SymbolHandle
-_backward_log_softmax name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log_softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Pooling(symbol)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),
-        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
-        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("p_value", AttrOpt (Maybe Int)),
-        '("count_include_pad", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt SymbolHandle)]
-
-_Pooling ::
-         forall args . Fullfilled "_Pooling(symbol)" args =>
-           String -> ArgsHMap "_Pooling(symbol)" args -> IO SymbolHandle
-_Pooling name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Pooling(symbol)" = '[]
-
-_backward_Pooling ::
-                  forall args . Fullfilled "_backward_Pooling(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_Pooling(symbol)" args -> IO SymbolHandle
-_backward_Pooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Deconvolution(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle)]
-
-_Deconvolution ::
-               forall args . Fullfilled "_Deconvolution(symbol)" args =>
-                 String -> ArgsHMap "_Deconvolution(symbol)" args -> IO SymbolHandle
-_Deconvolution name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Deconvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Deconvolution(symbol)" = '[]
-
-_backward_Deconvolution ::
-                        forall args . Fullfilled "_backward_Deconvolution(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_Deconvolution(symbol)" args -> IO SymbolHandle
-_backward_Deconvolution name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Deconvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Activation(symbol)" =
-     '[ '("act_type",
-          AttrReq
-            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_Activation ::
-            forall args . Fullfilled "_Activation(symbol)" args =>
-              String -> ArgsHMap "_Activation(symbol)" args -> IO SymbolHandle
-_Activation name args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Activation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Activation(symbol)" = '[]
-
-_backward_Activation ::
-                     forall args . Fullfilled "_backward_Activation(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_Activation(symbol)" args -> IO SymbolHandle
-_backward_Activation name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Activation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_UpSampling(symbol)" =
-     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),
-        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),
-        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),
-        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-_UpSampling ::
-            forall args . Fullfilled "_UpSampling(symbol)" args =>
-              String -> ArgsHMap "_UpSampling(symbol)" args -> IO SymbolHandle
-_UpSampling name args
-  = let scalarArgs
-          = catMaybes
-              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("sample_type",) . showValue <$>
-                 (args !? #sample_type ::
-                    Maybe (EnumType '["bilinear", "nearest"])),
-               ("multi_input_mode",) . showValue <$>
-                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "UpSampling"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_UpSampling(symbol)" = '[]
-
-_backward_UpSampling ::
-                     forall args . Fullfilled "_backward_UpSampling(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_UpSampling(symbol)" args -> IO SymbolHandle
-_backward_UpSampling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_UpSampling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BatchNorm(symbol)" =
-     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),
-        '("moving_mean", AttrOpt SymbolHandle),
-        '("moving_var", AttrOpt SymbolHandle)]
-
-_BatchNorm ::
-           forall args . Fullfilled "_BatchNorm(symbol)" args =>
-             String -> ArgsHMap "_BatchNorm(symbol)" args -> IO SymbolHandle
-_BatchNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_BatchNorm(symbol)" = '[]
-
-_backward_BatchNorm ::
-                    forall args . Fullfilled "_backward_BatchNorm(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_BatchNorm(symbol)" args -> IO SymbolHandle
-_backward_BatchNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_FullyConnected(symbol)" =
-     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
-        '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]
-
-_FullyConnected ::
-                forall args . Fullfilled "_FullyConnected(symbol)" args =>
-                  String ->
-                    ArgsHMap "_FullyConnected(symbol)" args -> IO SymbolHandle
-_FullyConnected name args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "FullyConnected"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_FullyConnected(symbol)" =
-     '[]
-
-_backward_FullyConnected ::
-                         forall args . Fullfilled "_backward_FullyConnected(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_FullyConnected(symbol)" args -> IO SymbolHandle
-_backward_FullyConnected name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_FullyConnected"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Convolution(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle)]
-
-_Convolution ::
-             forall args . Fullfilled "_Convolution(symbol)" args =>
-               String -> ArgsHMap "_Convolution(symbol)" args -> IO SymbolHandle
-_Convolution name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Convolution(symbol)" = '[]
-
-_backward_Convolution ::
-                      forall args . Fullfilled "_backward_Convolution(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_Convolution(symbol)" args -> IO SymbolHandle
-_backward_Convolution name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LayerNorm(symbol)" =
-     '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float),
-        '("output_mean_var", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle),
-        '("beta", AttrOpt SymbolHandle)]
-
-_LayerNorm ::
-           forall args . Fullfilled "_LayerNorm(symbol)" args =>
-             String -> ArgsHMap "_LayerNorm(symbol)" args -> IO SymbolHandle
-_LayerNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LayerNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_LayerNorm(symbol)" = '[]
-
-_backward_LayerNorm ::
-                    forall args . Fullfilled "_backward_LayerNorm(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_LayerNorm(symbol)" args -> IO SymbolHandle
-_backward_LayerNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LayerNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Concat(symbol)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-_Concat ::
-        forall args . Fullfilled "_Concat(symbol)" args =>
-          String -> ArgsHMap "_Concat(symbol)" args -> IO SymbolHandle
-_Concat name args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "Concat"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_Concat(symbol)" = '[]
-
-_backward_Concat ::
-                 forall args . Fullfilled "_backward_Concat(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_Concat(symbol)" args -> IO SymbolHandle
-_backward_Concat name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Concat"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rnn_param_concat(symbol)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-_rnn_param_concat ::
-                  forall args . Fullfilled "_rnn_param_concat(symbol)" args =>
-                    String ->
-                      ArgsHMap "_rnn_param_concat(symbol)" args -> IO SymbolHandle
-_rnn_param_concat name args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "_rnn_param_concat"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_SoftmaxActivation(symbol)" =
-     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_SoftmaxActivation ::
-                   forall args . Fullfilled "_SoftmaxActivation(symbol)" args =>
-                     String ->
-                       ArgsHMap "_SoftmaxActivation(symbol)" args -> IO SymbolHandle
-_SoftmaxActivation name args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxActivation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SoftmaxActivation(symbol)" =
-     '[]
-
-_backward_SoftmaxActivation ::
-                            forall args .
-                              Fullfilled "_backward_SoftmaxActivation(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_SoftmaxActivation(symbol)" args ->
-                                  IO SymbolHandle
-_backward_SoftmaxActivation name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxActivation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LRN(symbol)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),
-        '("data", AttrOpt SymbolHandle)]
-
-_LRN ::
-     forall args . Fullfilled "_LRN(symbol)" args =>
-       String -> ArgsHMap "_LRN(symbol)" args -> IO SymbolHandle
-_LRN name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),
-               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LRN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_LRN(symbol)" = '[]
-
-_backward_LRN ::
-              forall args . Fullfilled "_backward_LRN(symbol)" args =>
-                String -> ArgsHMap "_backward_LRN(symbol)" args -> IO SymbolHandle
-_backward_LRN name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LRN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Dropout(symbol)" =
-     '[ '("p", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["always", "training"])),
-        '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-_Dropout ::
-         forall args . Fullfilled "_Dropout(symbol)" args =>
-           String -> ArgsHMap "_Dropout(symbol)" args -> IO SymbolHandle
-_Dropout name args
-  = let scalarArgs
-          = catMaybes
-              [("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["always", "training"])),
-               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Dropout"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Dropout(symbol)" = '[]
-
-_backward_Dropout ::
-                  forall args . Fullfilled "_backward_Dropout(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_Dropout(symbol)" args -> IO SymbolHandle
-_backward_Dropout name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Dropout"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_dequantize(symbol)" =
-     '[ '("out_type", AttrOpt (EnumType '["float32"])),
-        '("data", AttrOpt SymbolHandle),
-        '("min_range", AttrOpt SymbolHandle),
-        '("max_range", AttrOpt SymbolHandle)]
-
-_contrib_dequantize ::
-                    forall args . Fullfilled "_contrib_dequantize(symbol)" args =>
-                      String ->
-                        ArgsHMap "_contrib_dequantize(symbol)" args -> IO SymbolHandle
-_contrib_dequantize name args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["float32"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dequantize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantized_flatten(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("min_data", AttrOpt SymbolHandle),
-        '("max_data", AttrOpt SymbolHandle)]
-
-_contrib_quantized_flatten ::
-                           forall args .
-                             Fullfilled "_contrib_quantized_flatten(symbol)" args =>
-                             String ->
-                               ArgsHMap "_contrib_quantized_flatten(symbol)" args ->
-                                 IO SymbolHandle
-_contrib_quantized_flatten name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_flatten"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantized_conv(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle),
-        '("min_data", AttrOpt SymbolHandle),
-        '("max_data", AttrOpt SymbolHandle),
-        '("min_weight", AttrOpt SymbolHandle),
-        '("max_weight", AttrOpt SymbolHandle),
-        '("min_bias", AttrOpt SymbolHandle),
-        '("max_bias", AttrOpt SymbolHandle)]
-
-_contrib_quantized_conv ::
-                        forall args . Fullfilled "_contrib_quantized_conv(symbol)" args =>
-                          String ->
-                            ArgsHMap "_contrib_quantized_conv(symbol)" args -> IO SymbolHandle
-_contrib_quantized_conv name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_conv"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_contrib_quantized_fully_connected(symbol)" =
-     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
-        '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle),
-        '("min_data", AttrOpt SymbolHandle),
-        '("max_data", AttrOpt SymbolHandle),
-        '("min_weight", AttrOpt SymbolHandle),
-        '("max_weight", AttrOpt SymbolHandle),
-        '("min_bias", AttrOpt SymbolHandle),
-        '("max_bias", AttrOpt SymbolHandle)]
-
-_contrib_quantized_fully_connected ::
-                                   forall args .
-                                     Fullfilled "_contrib_quantized_fully_connected(symbol)" args =>
-                                     String ->
-                                       ArgsHMap "_contrib_quantized_fully_connected(symbol)" args ->
-                                         IO SymbolHandle
-_contrib_quantized_fully_connected name args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantized_pooling(symbol)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),
-        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
-        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("p_value", AttrOpt (Maybe Int)),
-        '("count_include_pad", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt SymbolHandle),
-        '("min_data", AttrOpt SymbolHandle),
-        '("max_data", AttrOpt SymbolHandle)]
-
-_contrib_quantized_pooling ::
-                           forall args .
-                             Fullfilled "_contrib_quantized_pooling(symbol)" args =>
-                             String ->
-                               ArgsHMap "_contrib_quantized_pooling(symbol)" args ->
-                                 IO SymbolHandle
-_contrib_quantized_pooling name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_pooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_requantize(symbol)" =
-     '[ '("min_calib_range", AttrOpt (Maybe Float)),
-        '("max_calib_range", AttrOpt (Maybe Float)),
-        '("data", AttrOpt SymbolHandle),
-        '("min_range", AttrOpt SymbolHandle),
-        '("max_range", AttrOpt SymbolHandle)]
-
-_contrib_requantize ::
-                    forall args . Fullfilled "_contrib_requantize(symbol)" args =>
-                      String ->
-                        ArgsHMap "_contrib_requantize(symbol)" args -> IO SymbolHandle
-_contrib_requantize name args
-  = let scalarArgs
-          = catMaybes
-              [("min_calib_range",) . showValue <$>
-                 (args !? #min_calib_range :: Maybe (Maybe Float)),
-               ("max_calib_range",) . showValue <$>
-                 (args !? #max_calib_range :: Maybe (Maybe Float))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_requantize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantize(symbol)" =
-     '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])),
-        '("data", AttrOpt SymbolHandle),
-        '("min_range", AttrOpt SymbolHandle),
-        '("max_range", AttrOpt SymbolHandle)]
-
-_contrib_quantize ::
-                  forall args . Fullfilled "_contrib_quantize(symbol)" args =>
-                    String ->
-                      ArgsHMap "_contrib_quantize(symbol)" args -> IO SymbolHandle
-_contrib_quantize name args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_cvimread(symbol)" =
-     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),
-        '("to_rgb", AttrOpt Bool)]
-
-_cvimread ::
-          forall args . Fullfilled "_cvimread(symbol)" args =>
-            String -> ArgsHMap "_cvimread(symbol)" args -> IO SymbolHandle
-_cvimread name args
-  = let scalarArgs
-          = catMaybes
-              [("filename",) . showValue <$> (args !? #filename :: Maybe String),
-               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimread"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_NoGradient(symbol)" = '[]
-
-_NoGradient ::
-            forall args . Fullfilled "_NoGradient(symbol)" args =>
-              String -> ArgsHMap "_NoGradient(symbol)" args -> IO SymbolHandle
-_NoGradient name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_NoGradient"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CachedOp(symbol)" = '[]
-
-_CachedOp ::
-          forall args . Fullfilled "_CachedOp(symbol)" args =>
-            String -> ArgsHMap "_CachedOp(symbol)" args -> IO SymbolHandle
-_CachedOp name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CachedOp"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_CachedOp(symbol)" = '[]
-
-_backward_CachedOp ::
-                   forall args . Fullfilled "_backward_CachedOp(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_CachedOp(symbol)" args -> IO SymbolHandle
-_backward_CachedOp name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CachedOp"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "softmax_cross_entropy(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-softmax_cross_entropy ::
-                      forall args . Fullfilled "softmax_cross_entropy(symbol)" args =>
-                        String ->
-                          ArgsHMap "softmax_cross_entropy(symbol)" args -> IO SymbolHandle
-softmax_cross_entropy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax_cross_entropy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_softmax_cross_entropy(symbol)" = '[]
-
-_backward_softmax_cross_entropy ::
-                                forall args .
-                                  Fullfilled "_backward_softmax_cross_entropy(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_backward_softmax_cross_entropy(symbol)" args ->
-                                      IO SymbolHandle
-_backward_softmax_cross_entropy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Pad(symbol)" =
-     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),
-        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),
-        '("data", AttrOpt SymbolHandle)]
-
-_Pad ::
-     forall args . Fullfilled "_Pad(symbol)" args =>
-       String -> ArgsHMap "_Pad(symbol)" args -> IO SymbolHandle
-_Pad name args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["constant", "edge", "reflect"])),
-               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),
-               ("constant_value",) . showValue <$>
-                 (args !? #constant_value :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pad"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_foreach(symbol)" = '[]
-
-_backward_foreach ::
-                  forall args . Fullfilled "_backward_foreach(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_foreach(symbol)" args -> IO SymbolHandle
-_backward_foreach name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_foreach"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_while_loop(symbol)" = '[]
-
-_backward_while_loop ::
-                     forall args . Fullfilled "_backward_while_loop(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_while_loop(symbol)" args -> IO SymbolHandle
-_backward_while_loop name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_while_loop"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cond(symbol)" = '[]
-
-_backward_cond ::
-               forall args . Fullfilled "_backward_cond(symbol)" args =>
-                 String -> ArgsHMap "_backward_cond(symbol)" args -> IO SymbolHandle
-_backward_cond name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cond"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LeakyReLU(symbol)" =
-     '[ '("act_type",
-          AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),
-        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),
-        '("upper_bound", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle)]
-
-_LeakyReLU ::
-           forall args . Fullfilled "_LeakyReLU(symbol)" args =>
-             String -> ArgsHMap "_LeakyReLU(symbol)" args -> IO SymbolHandle
-_LeakyReLU name args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),
-               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),
-               ("lower_bound",) . showValue <$>
-                 (args !? #lower_bound :: Maybe Float),
-               ("upper_bound",) . showValue <$>
-                 (args !? #upper_bound :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LeakyReLU"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SwapAxis(symbol)" =
-     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle)]
-
-_SwapAxis ::
-          forall args . Fullfilled "_SwapAxis(symbol)" args =>
-            String -> ArgsHMap "_SwapAxis(symbol)" args -> IO SymbolHandle
-_SwapAxis name args
-  = let scalarArgs
-          = catMaybes
-              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),
-               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SwapAxis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_IdentityAttachKLSparseReg(symbol)" =
-     '[ '("sparseness_target", AttrOpt Float),
-        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_IdentityAttachKLSparseReg ::
-                           forall args .
-                             Fullfilled "_IdentityAttachKLSparseReg(symbol)" args =>
-                             String ->
-                               ArgsHMap "_IdentityAttachKLSparseReg(symbol)" args ->
-                                 IO SymbolHandle
-_IdentityAttachKLSparseReg name args
-  = let scalarArgs
-          = catMaybes
-              [("sparseness_target",) . showValue <$>
-                 (args !? #sparseness_target :: Maybe Float),
-               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SliceChannel(symbol)" =
-     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),
-        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-_SliceChannel ::
-              forall args . Fullfilled "_SliceChannel(symbol)" args =>
-                String -> ArgsHMap "_SliceChannel(symbol)" args -> IO SymbolHandle
-_SliceChannel name args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SliceChannel"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BatchNorm_v1(symbol)" =
-     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle),
-        '("beta", AttrOpt SymbolHandle)]
-
-_BatchNorm_v1 ::
-              forall args . Fullfilled "_BatchNorm_v1(symbol)" args =>
-                String -> ArgsHMap "_BatchNorm_v1(symbol)" args -> IO SymbolHandle
-_BatchNorm_v1 name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "signsgd_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)]
-
-signsgd_update ::
-               forall args . Fullfilled "signsgd_update(symbol)" args =>
-                 String -> ArgsHMap "signsgd_update(symbol)" args -> IO SymbolHandle
-signsgd_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signsgd_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "signum_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mom", AttrOpt SymbolHandle)]
-
-signum_update ::
-              forall args . Fullfilled "signum_update(symbol)" args =>
-                String -> ArgsHMap "signum_update(symbol)" args -> IO SymbolHandle
-signum_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signum_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sgd_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)]
-
-sgd_update ::
-           forall args . Fullfilled "sgd_update(symbol)" args =>
-             String -> ArgsHMap "sgd_update(symbol)" args -> IO SymbolHandle
-sgd_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sgd_mom_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mom", AttrOpt SymbolHandle)]
-
-sgd_mom_update ::
-               forall args . Fullfilled "sgd_mom_update(symbol)" args =>
-                 String -> ArgsHMap "sgd_mom_update(symbol)" args -> IO SymbolHandle
-sgd_mom_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_mom_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "mp_sgd_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("weight32", AttrOpt SymbolHandle)]
-
-mp_sgd_update ::
-              forall args . Fullfilled "mp_sgd_update(symbol)" args =>
-                String -> ArgsHMap "mp_sgd_update(symbol)" args -> IO SymbolHandle
-mp_sgd_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "mp_sgd_mom_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mom", AttrOpt SymbolHandle),
-        '("weight32", AttrOpt SymbolHandle)]
-
-mp_sgd_mom_update ::
-                  forall args . Fullfilled "mp_sgd_mom_update(symbol)" args =>
-                    String ->
-                      ArgsHMap "mp_sgd_mom_update(symbol)" args -> IO SymbolHandle
-mp_sgd_mom_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_mom_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ftml_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double),
-        '("t", AttrReq Int), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("d", AttrOpt SymbolHandle), '("v", AttrOpt SymbolHandle),
-        '("z", AttrOpt SymbolHandle)]
-
-ftml_update ::
-            forall args . Fullfilled "ftml_update(symbol)" args =>
-              String -> ArgsHMap "ftml_update(symbol)" args -> IO SymbolHandle
-ftml_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),
-               ("t",) . showValue <$> (args !? #t :: Maybe Int),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("d",) <$> (args !? #d :: Maybe SymbolHandle),
-               ("v",) <$> (args !? #v :: Maybe SymbolHandle),
-               ("z",) <$> (args !? #z :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftml_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "adam_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle)]
-
-adam_update ::
-            forall args . Fullfilled "adam_update(symbol)" args =>
-              String -> ArgsHMap "adam_update(symbol)" args -> IO SymbolHandle
-adam_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mean",) <$> (args !? #mean :: Maybe SymbolHandle),
-               ("var",) <$> (args !? #var :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "adam_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rmsprop_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("n", AttrOpt SymbolHandle)]
-
-rmsprop_update ::
-               forall args . Fullfilled "rmsprop_update(symbol)" args =>
-                 String -> ArgsHMap "rmsprop_update(symbol)" args -> IO SymbolHandle
-rmsprop_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmsprop_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rmspropalex_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("n", AttrOpt SymbolHandle), '("g", AttrOpt SymbolHandle),
-        '("delta", AttrOpt SymbolHandle)]
-
-rmspropalex_update ::
-                   forall args . Fullfilled "rmspropalex_update(symbol)" args =>
-                     String ->
-                       ArgsHMap "rmspropalex_update(symbol)" args -> IO SymbolHandle
-rmspropalex_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("n",) <$> (args !? #n :: Maybe SymbolHandle),
-               ("g",) <$> (args !? #g :: Maybe SymbolHandle),
-               ("delta",) <$> (args !? #delta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmspropalex_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ftrl_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),
-        '("beta", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("z", AttrOpt SymbolHandle), '("n", AttrOpt SymbolHandle)]
-
-ftrl_update ::
-            forall args . Fullfilled "ftrl_update(symbol)" args =>
-              String -> ArgsHMap "ftrl_update(symbol)" args -> IO SymbolHandle
-ftrl_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("z",) <$> (args !? #z :: Maybe SymbolHandle),
-               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftrl_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sparse_adagrad_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("history", AttrOpt SymbolHandle)]
-
-_sparse_adagrad_update ::
-                       forall args . Fullfilled "_sparse_adagrad_update(symbol)" args =>
-                         String ->
-                           ArgsHMap "_sparse_adagrad_update(symbol)" args -> IO SymbolHandle
-_sparse_adagrad_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("history",) <$> (args !? #history :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_adagrad_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LinearRegressionOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_LinearRegressionOutput ::
-                        forall args . Fullfilled "_LinearRegressionOutput(symbol)" args =>
-                          String ->
-                            ArgsHMap "_LinearRegressionOutput(symbol)" args -> IO SymbolHandle
-_LinearRegressionOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LinearRegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linear_reg_out(symbol)" =
-     '[]
-
-_backward_linear_reg_out ::
-                         forall args . Fullfilled "_backward_linear_reg_out(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_linear_reg_out(symbol)" args -> IO SymbolHandle
-_backward_linear_reg_out name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linear_reg_out"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_MAERegressionOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_MAERegressionOutput ::
-                     forall args . Fullfilled "_MAERegressionOutput(symbol)" args =>
-                       String ->
-                         ArgsHMap "_MAERegressionOutput(symbol)" args -> IO SymbolHandle
-_MAERegressionOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MAERegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mae_reg_out(symbol)" = '[]
-
-_backward_mae_reg_out ::
-                      forall args . Fullfilled "_backward_mae_reg_out(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_mae_reg_out(symbol)" args -> IO SymbolHandle
-_backward_mae_reg_out name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mae_reg_out"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LogisticRegressionOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_LogisticRegressionOutput ::
-                          forall args .
-                            Fullfilled "_LogisticRegressionOutput(symbol)" args =>
-                            String ->
-                              ArgsHMap "_LogisticRegressionOutput(symbol)" args ->
-                                IO SymbolHandle
-_LogisticRegressionOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LogisticRegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_logistic_reg_out(symbol)" =
-     '[]
-
-_backward_logistic_reg_out ::
-                           forall args .
-                             Fullfilled "_backward_logistic_reg_out(symbol)" args =>
-                             String ->
-                               ArgsHMap "_backward_logistic_reg_out(symbol)" args ->
-                                 IO SymbolHandle
-_backward_logistic_reg_out name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_logistic_reg_out"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CustomFunction(symbol)" = '[]
-
-_CustomFunction ::
-                forall args . Fullfilled "_CustomFunction(symbol)" args =>
-                  String ->
-                    ArgsHMap "_CustomFunction(symbol)" args -> IO SymbolHandle
-_CustomFunction name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CustomFunction"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_CustomFunction(symbol)" =
-     '[]
-
-_backward_CustomFunction ::
-                         forall args . Fullfilled "_backward_CustomFunction(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_CustomFunction(symbol)" args -> IO SymbolHandle
-_backward_CustomFunction name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CustomFunction"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__Native(symbol)" = '[]
-
-_backward__Native ::
-                  forall args . Fullfilled "_backward__Native(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward__Native(symbol)" args -> IO SymbolHandle
-_backward__Native name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__Native"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__NDArray(symbol)" = '[]
-
-_backward__NDArray ::
-                   forall args . Fullfilled "_backward__NDArray(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward__NDArray(symbol)" args -> IO SymbolHandle
-_backward__NDArray name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__NDArray"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiBoxTarget(symbol)" =
-     '[ '("overlap_threshold", AttrOpt Float),
-        '("ignore_label", AttrOpt Float),
-        '("negative_mining_ratio", AttrOpt Float),
-        '("negative_mining_thresh", AttrOpt Float),
-        '("minimum_negative_samples", AttrOpt Int),
-        '("variances", AttrOpt [Float]), '("anchor", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle),
-        '("cls_pred", AttrOpt SymbolHandle)]
-
-_contrib_MultiBoxTarget ::
-                        forall args . Fullfilled "_contrib_MultiBoxTarget(symbol)" args =>
-                          String ->
-                            ArgsHMap "_contrib_MultiBoxTarget(symbol)" args -> IO SymbolHandle
-_contrib_MultiBoxTarget name args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_threshold",) . showValue <$>
-                 (args !? #overlap_threshold :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("negative_mining_ratio",) . showValue <$>
-                 (args !? #negative_mining_ratio :: Maybe Float),
-               ("negative_mining_thresh",) . showValue <$>
-                 (args !? #negative_mining_thresh :: Maybe Float),
-               ("minimum_negative_samples",) . showValue <$>
-                 (args !? #minimum_negative_samples :: Maybe Int),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle),
-               ("cls_pred",) <$> (args !? #cls_pred :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxTarget(symbol)" = '[]
-
-_backward__contrib_MultiBoxTarget ::
-                                  forall args .
-                                    Fullfilled "_backward__contrib_MultiBoxTarget(symbol)" args =>
-                                    String ->
-                                      ArgsHMap "_backward__contrib_MultiBoxTarget(symbol)" args ->
-                                        IO SymbolHandle
-_backward__contrib_MultiBoxTarget name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_Proposal(symbol)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle),
-        '("bbox_pred", AttrOpt SymbolHandle),
-        '("im_info", AttrOpt SymbolHandle)]
-
-_contrib_Proposal ::
-                  forall args . Fullfilled "_contrib_Proposal(symbol)" args =>
-                    String ->
-                      ArgsHMap "_contrib_Proposal(symbol)" args -> IO SymbolHandle
-_contrib_Proposal name args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_Proposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__contrib_Proposal(symbol)" =
-     '[]
-
-_backward__contrib_Proposal ::
-                            forall args .
-                              Fullfilled "_backward__contrib_Proposal(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward__contrib_Proposal(symbol)" args ->
-                                  IO SymbolHandle
-_backward__contrib_Proposal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_Proposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_count_sketch(symbol)" =
-     '[ '("out_dim", AttrReq Int),
-        '("processing_batch_size", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle), '("h", AttrOpt SymbolHandle),
-        '("s", AttrOpt SymbolHandle)]
-
-_contrib_count_sketch ::
-                      forall args . Fullfilled "_contrib_count_sketch(symbol)" args =>
-                        String ->
-                          ArgsHMap "_contrib_count_sketch(symbol)" args -> IO SymbolHandle
-_contrib_count_sketch name args
-  = let scalarArgs
-          = catMaybes
-              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),
-               ("processing_batch_size",) . showValue <$>
-                 (args !? #processing_batch_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("h",) <$> (args !? #h :: Maybe SymbolHandle),
-               ("s",) <$> (args !? #s :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_count_sketch"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_count_sketch(symbol)" = '[]
-
-_backward__contrib_count_sketch ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_count_sketch(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_backward__contrib_count_sketch(symbol)" args ->
-                                      IO SymbolHandle
-_backward__contrib_count_sketch name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_count_sketch"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiBoxDetection(symbol)" =
-     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),
-        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),
-        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),
-        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt SymbolHandle),
-        '("loc_pred", AttrOpt SymbolHandle),
-        '("anchor", AttrOpt SymbolHandle)]
-
-_contrib_MultiBoxDetection ::
-                           forall args .
-                             Fullfilled "_contrib_MultiBoxDetection(symbol)" args =>
-                             String ->
-                               ArgsHMap "_contrib_MultiBoxDetection(symbol)" args ->
-                                 IO SymbolHandle
-_contrib_MultiBoxDetection name args
-  = let scalarArgs
-          = catMaybes
-              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("nms_threshold",) . showValue <$>
-                 (args !? #nms_threshold :: Maybe Float),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float]),
-               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),
-               ("loc_pred",) <$> (args !? #loc_pred :: Maybe SymbolHandle),
-               ("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxDetection(symbol)" = '[]
-
-_backward__contrib_MultiBoxDetection ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiBoxDetection(symbol)"
-                                         args =>
-                                       String ->
-                                         ArgsHMap "_backward__contrib_MultiBoxDetection(symbol)"
-                                           args
-                                           -> IO SymbolHandle
-_backward__contrib_MultiBoxDetection name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_contrib_DeformablePSROIPooling(symbol)" =
-     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),
-        '("group_size", AttrReq Int), '("pooled_size", AttrReq Int),
-        '("part_size", AttrOpt Int), '("sample_per_part", AttrOpt Int),
-        '("trans_std", AttrOpt Float), '("no_trans", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle),
-        '("trans", AttrOpt SymbolHandle)]
-
-_contrib_DeformablePSROIPooling ::
-                                forall args .
-                                  Fullfilled "_contrib_DeformablePSROIPooling(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_contrib_DeformablePSROIPooling(symbol)" args ->
-                                      IO SymbolHandle
-_contrib_DeformablePSROIPooling name args
-  = let scalarArgs
-          = catMaybes
-              [("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int),
-               ("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe Int),
-               ("part_size",) . showValue <$> (args !? #part_size :: Maybe Int),
-               ("sample_per_part",) . showValue <$>
-                 (args !? #sample_per_part :: Maybe Int),
-               ("trans_std",) . showValue <$> (args !? #trans_std :: Maybe Float),
-               ("no_trans",) . showValue <$> (args !? #no_trans :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle),
-               ("trans",) <$> (args !? #trans :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformablePSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_DeformablePSROIPooling(symbol)" =
-     '[]
-
-_backward__contrib_DeformablePSROIPooling ::
-                                          forall args .
-                                            Fullfilled
-                                              "_backward__contrib_DeformablePSROIPooling(symbol)"
-                                              args =>
-                                            String ->
-                                              ArgsHMap
-                                                "_backward__contrib_DeformablePSROIPooling(symbol)"
-                                                args
-                                                -> IO SymbolHandle
-_backward__contrib_DeformablePSROIPooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__contrib_CTCLoss(symbol)" =
-     '[]
-
-_backward__contrib_CTCLoss ::
-                           forall args .
-                             Fullfilled "_backward__contrib_CTCLoss(symbol)" args =>
-                             String ->
-                               ArgsHMap "_backward__contrib_CTCLoss(symbol)" args ->
-                                 IO SymbolHandle
-_backward__contrib_CTCLoss name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_CTCLoss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiProposal(symbol)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle),
-        '("bbox_pred", AttrOpt SymbolHandle),
-        '("im_info", AttrOpt SymbolHandle)]
-
-_contrib_MultiProposal ::
-                       forall args . Fullfilled "_contrib_MultiProposal(symbol)" args =>
-                         String ->
-                           ArgsHMap "_contrib_MultiProposal(symbol)" args -> IO SymbolHandle
-_contrib_MultiProposal name args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiProposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiProposal(symbol)" = '[]
-
-_backward__contrib_MultiProposal ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiProposal(symbol)" args =>
-                                   String ->
-                                     ArgsHMap "_backward__contrib_MultiProposal(symbol)" args ->
-                                       IO SymbolHandle
-_backward__contrib_MultiProposal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiBoxPrior(symbol)" =
-     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),
-        '("offsets", AttrOpt [Float]), '("data", AttrOpt SymbolHandle)]
-
-_contrib_MultiBoxPrior ::
-                       forall args . Fullfilled "_contrib_MultiBoxPrior(symbol)" args =>
-                         String ->
-                           ArgsHMap "_contrib_MultiBoxPrior(symbol)" args -> IO SymbolHandle
-_contrib_MultiBoxPrior name args
-  = let scalarArgs
-          = catMaybes
-              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),
-               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxPrior(symbol)" = '[]
-
-_backward__contrib_MultiBoxPrior ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiBoxPrior(symbol)" args =>
-                                   String ->
-                                     ArgsHMap "_backward__contrib_MultiBoxPrior(symbol)" args ->
-                                       IO SymbolHandle
-_backward__contrib_MultiBoxPrior name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_fft(symbol)" =
-     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-_contrib_fft ::
-             forall args . Fullfilled "_contrib_fft(symbol)" args =>
-               String -> ArgsHMap "_contrib_fft(symbol)" args -> IO SymbolHandle
-_contrib_fft name args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_fft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__contrib_fft(symbol)" = '[]
-
-_backward__contrib_fft ::
-                       forall args . Fullfilled "_backward__contrib_fft(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward__contrib_fft(symbol)" args -> IO SymbolHandle
-_backward__contrib_fft name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_fft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_PSROIPooling(symbol)" =
-     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),
-        '("pooled_size", AttrReq Int), '("group_size", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)]
-
-_contrib_PSROIPooling ::
-                      forall args . Fullfilled "_contrib_PSROIPooling(symbol)" args =>
-                        String ->
-                          ArgsHMap "_contrib_PSROIPooling(symbol)" args -> IO SymbolHandle
-_contrib_PSROIPooling name args
-  = let scalarArgs
-          = catMaybes
-              [("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe Int),
-               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_PSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_PSROIPooling(symbol)" = '[]
-
-_backward__contrib_PSROIPooling ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_PSROIPooling(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_backward__contrib_PSROIPooling(symbol)" args ->
-                                      IO SymbolHandle
-_backward__contrib_PSROIPooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_contrib_DeformableConvolution(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("num_deformable_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),
-        '("data", AttrOpt SymbolHandle), '("offset", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]
-
-_contrib_DeformableConvolution ::
-                               forall args .
-                                 Fullfilled "_contrib_DeformableConvolution(symbol)" args =>
-                                 String ->
-                                   ArgsHMap "_contrib_DeformableConvolution(symbol)" args ->
-                                     IO SymbolHandle
-_contrib_DeformableConvolution name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("num_deformable_group",) . showValue <$>
-                 (args !? #num_deformable_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("offset",) <$> (args !? #offset :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformableConvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_DeformableConvolution(symbol)" =
-     '[]
-
-_backward__contrib_DeformableConvolution ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward__contrib_DeformableConvolution(symbol)"
-                                             args =>
-                                           String ->
-                                             ArgsHMap
-                                               "_backward__contrib_DeformableConvolution(symbol)"
-                                               args
-                                               -> IO SymbolHandle
-_backward__contrib_DeformableConvolution name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_ifft(symbol)" =
-     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-_contrib_ifft ::
-              forall args . Fullfilled "_contrib_ifft(symbol)" args =>
-                String -> ArgsHMap "_contrib_ifft(symbol)" args -> IO SymbolHandle
-_contrib_ifft name args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ifft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__contrib_ifft(symbol)" = '[]
-
-_backward__contrib_ifft ::
-                        forall args . Fullfilled "_backward__contrib_ifft(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward__contrib_ifft(symbol)" args -> IO SymbolHandle
-_backward__contrib_ifft name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_ifft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_SyncBatchNorm(symbol)" = '[]
-
-_backward__contrib_SyncBatchNorm ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_SyncBatchNorm(symbol)" args =>
-                                   String ->
-                                     ArgsHMap "_backward__contrib_SyncBatchNorm(symbol)" args ->
-                                       IO SymbolHandle
-_backward__contrib_SyncBatchNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_InstanceNorm(symbol)" =
-     '[ '("eps", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]
-
-_InstanceNorm ::
-              forall args . Fullfilled "_InstanceNorm(symbol)" args =>
-                String -> ArgsHMap "_InstanceNorm(symbol)" args -> IO SymbolHandle
-_InstanceNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "InstanceNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_InstanceNorm(symbol)" = '[]
-
-_backward_InstanceNorm ::
-                       forall args . Fullfilled "_backward_InstanceNorm(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_InstanceNorm(symbol)" args -> IO SymbolHandle
-_backward_InstanceNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_InstanceNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SVMOutput(symbol)" =
-     '[ '("margin", AttrOpt Float),
-        '("regularization_coefficient", AttrOpt Float),
-        '("use_linear", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_SVMOutput ::
-           forall args . Fullfilled "_SVMOutput(symbol)" args =>
-             String -> ArgsHMap "_SVMOutput(symbol)" args -> IO SymbolHandle
-_SVMOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),
-               ("regularization_coefficient",) . showValue <$>
-                 (args !? #regularization_coefficient :: Maybe Float),
-               ("use_linear",) . showValue <$>
-                 (args !? #use_linear :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SVMOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SVMOutput(symbol)" = '[]
-
-_backward_SVMOutput ::
-                    forall args . Fullfilled "_backward_SVMOutput(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_SVMOutput(symbol)" args -> IO SymbolHandle
-_backward_SVMOutput name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SVMOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_GridGenerator(symbol)" =
-     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),
-        '("target_shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-_GridGenerator ::
-               forall args . Fullfilled "_GridGenerator(symbol)" args =>
-                 String -> ArgsHMap "_GridGenerator(symbol)" args -> IO SymbolHandle
-_GridGenerator name args
-  = let scalarArgs
-          = catMaybes
-              [("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "GridGenerator"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_GridGenerator(symbol)" = '[]
-
-_backward_GridGenerator ::
-                        forall args . Fullfilled "_backward_GridGenerator(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_GridGenerator(symbol)" args -> IO SymbolHandle
-_backward_GridGenerator name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_GridGenerator"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Pad(symbol)" = '[]
-
-_backward_Pad ::
-              forall args . Fullfilled "_backward_Pad(symbol)" args =>
-                String -> ArgsHMap "_backward_Pad(symbol)" args -> IO SymbolHandle
-_backward_Pad name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pad"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Convolution_v1(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle)]
-
-_Convolution_v1 ::
-                forall args . Fullfilled "_Convolution_v1(symbol)" args =>
-                  String ->
-                    ArgsHMap "_Convolution_v1(symbol)" args -> IO SymbolHandle
-_Convolution_v1 name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Convolution_v1(symbol)" =
-     '[]
-
-_backward_Convolution_v1 ::
-                         forall args . Fullfilled "_backward_Convolution_v1(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_Convolution_v1(symbol)" args -> IO SymbolHandle
-_backward_Convolution_v1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SequenceReverse(symbol)" =
-     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle),
-        '("sequence_length", AttrOpt SymbolHandle)]
-
-_SequenceReverse ::
-                 forall args . Fullfilled "_SequenceReverse(symbol)" args =>
-                   String ->
-                     ArgsHMap "_SequenceReverse(symbol)" args -> IO SymbolHandle
-_SequenceReverse name args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceReverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SequenceReverse(symbol)" =
-     '[]
-
-_backward_SequenceReverse ::
-                          forall args .
-                            Fullfilled "_backward_SequenceReverse(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_SequenceReverse(symbol)" args ->
-                                IO SymbolHandle
-_backward_SequenceReverse name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceReverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SoftmaxOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
-        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle)]
-
-_SoftmaxOutput ::
-               forall args . Fullfilled "_SoftmaxOutput(symbol)" args =>
-                 String -> ArgsHMap "_SoftmaxOutput(symbol)" args -> IO SymbolHandle
-_SoftmaxOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SoftmaxOutput(symbol)" = '[]
-
-_backward_SoftmaxOutput ::
-                        forall args . Fullfilled "_backward_SoftmaxOutput(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_SoftmaxOutput(symbol)" args -> IO SymbolHandle
-_backward_SoftmaxOutput name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Softmax(symbol)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
-        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_Softmax ::
-         forall args . Fullfilled "_Softmax(symbol)" args =>
-           String -> ArgsHMap "_Softmax(symbol)" args -> IO SymbolHandle
-_Softmax name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Softmax(symbol)" = '[]
-
-_backward_Softmax ::
-                  forall args . Fullfilled "_backward_Softmax(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_Softmax(symbol)" args -> IO SymbolHandle
-_backward_Softmax name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BilinearSampler(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("grid", AttrOpt SymbolHandle)]
-
-_BilinearSampler ::
-                 forall args . Fullfilled "_BilinearSampler(symbol)" args =>
-                   String ->
-                     ArgsHMap "_BilinearSampler(symbol)" args -> IO SymbolHandle
-_BilinearSampler name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("grid",) <$> (args !? #grid :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BilinearSampler"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_BilinearSampler(symbol)" =
-     '[]
-
-_backward_BilinearSampler ::
-                          forall args .
-                            Fullfilled "_backward_BilinearSampler(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_BilinearSampler(symbol)" args ->
-                                IO SymbolHandle
-_backward_BilinearSampler name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BilinearSampler"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_LeakyReLU(symbol)" = '[]
-
-_backward_LeakyReLU ::
-                    forall args . Fullfilled "_backward_LeakyReLU(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_LeakyReLU(symbol)" args -> IO SymbolHandle
-_backward_LeakyReLU name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LeakyReLU"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Crop(symbol)" =
-     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),
-        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),
-        '("data", AttrOpt [SymbolHandle])]
-
-_Crop ::
-      forall args . Fullfilled "_Crop(symbol)" args =>
-        String -> ArgsHMap "_Crop(symbol)" args -> IO SymbolHandle
-_Crop name args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),
-               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),
-               ("center_crop",) . showValue <$>
-                 (args !? #center_crop :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "Crop"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_Crop(symbol)" = '[]
-
-_backward_Crop ::
-               forall args . Fullfilled "_backward_Crop(symbol)" args =>
-                 String -> ArgsHMap "_backward_Crop(symbol)" args -> IO SymbolHandle
-_backward_Crop name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Crop"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_ROIPooling(symbol)" =
-     '[ '("pooled_size", AttrReq [Int]),
-        '("spatial_scale", AttrReq Float), '("data", AttrOpt SymbolHandle),
-        '("rois", AttrOpt SymbolHandle)]
-
-_ROIPooling ::
-            forall args . Fullfilled "_ROIPooling(symbol)" args =>
-              String -> ArgsHMap "_ROIPooling(symbol)" args -> IO SymbolHandle
-_ROIPooling name args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_ROIPooling(symbol)" = '[]
-
-_backward_ROIPooling ::
-                     forall args . Fullfilled "_backward_ROIPooling(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_ROIPooling(symbol)" args -> IO SymbolHandle
-_backward_ROIPooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SequenceLast(symbol)" =
-     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle),
-        '("sequence_length", AttrOpt SymbolHandle)]
-
-_SequenceLast ::
-              forall args . Fullfilled "_SequenceLast(symbol)" args =>
-                String -> ArgsHMap "_SequenceLast(symbol)" args -> IO SymbolHandle
-_SequenceLast name args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceLast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SequenceLast(symbol)" = '[]
-
-_backward_SequenceLast ::
-                       forall args . Fullfilled "_backward_SequenceLast(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_SequenceLast(symbol)" args -> IO SymbolHandle
-_backward_SequenceLast name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceLast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CrossDeviceCopy(symbol)" = '[]
-
-_CrossDeviceCopy ::
-                 forall args . Fullfilled "_CrossDeviceCopy(symbol)" args =>
-                   String ->
-                     ArgsHMap "_CrossDeviceCopy(symbol)" args -> IO SymbolHandle
-_CrossDeviceCopy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CrossDeviceCopy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__CrossDeviceCopy(symbol)" =
-     '[]
-
-_backward__CrossDeviceCopy ::
-                           forall args .
-                             Fullfilled "_backward__CrossDeviceCopy(symbol)" args =>
-                             String ->
-                               ArgsHMap "_backward__CrossDeviceCopy(symbol)" args ->
-                                 IO SymbolHandle
-_backward__CrossDeviceCopy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SpatialTransformer(symbol)" =
-     '[ '("target_shape", AttrOpt [Int]),
-        '("transform_type", AttrReq (EnumType '["affine"])),
-        '("sampler_type", AttrReq (EnumType '["bilinear"])),
-        '("data", AttrOpt SymbolHandle), '("loc", AttrOpt SymbolHandle)]
-
-_SpatialTransformer ::
-                    forall args . Fullfilled "_SpatialTransformer(symbol)" args =>
-                      String ->
-                        ArgsHMap "_SpatialTransformer(symbol)" args -> IO SymbolHandle
-_SpatialTransformer name args
-  = let scalarArgs
-          = catMaybes
-              [("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine"])),
-               ("sampler_type",) . showValue <$>
-                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("loc",) <$> (args !? #loc :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SpatialTransformer"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SpatialTransformer(symbol)"
-     = '[]
-
-_backward_SpatialTransformer ::
-                             forall args .
-                               Fullfilled "_backward_SpatialTransformer(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_backward_SpatialTransformer(symbol)" args ->
-                                   IO SymbolHandle
-_backward_SpatialTransformer name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SpatialTransformer"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SwapAxis(symbol)" = '[]
-
-_backward_SwapAxis ::
-                   forall args . Fullfilled "_backward_SwapAxis(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_SwapAxis(symbol)" args -> IO SymbolHandle
-_backward_SwapAxis name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SwapAxis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_L2Normalization(symbol)" =
-     '[ '("eps", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_L2Normalization ::
-                 forall args . Fullfilled "_L2Normalization(symbol)" args =>
-                   String ->
-                     ArgsHMap "_L2Normalization(symbol)" args -> IO SymbolHandle
-_L2Normalization name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["channel", "instance", "spatial"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "L2Normalization"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_L2Normalization(symbol)" =
-     '[]
-
-_backward_L2Normalization ::
-                          forall args .
-                            Fullfilled "_backward_L2Normalization(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_L2Normalization(symbol)" args ->
-                                IO SymbolHandle
-_backward_L2Normalization name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_L2Normalization"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Correlation(symbol)" =
-     '[ '("kernel_size", AttrOpt Int),
-        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),
-        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),
-        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt SymbolHandle),
-        '("data2", AttrOpt SymbolHandle)]
-
-_Correlation ::
-             forall args . Fullfilled "_Correlation(symbol)" args =>
-               String -> ArgsHMap "_Correlation(symbol)" args -> IO SymbolHandle
-_Correlation name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel_size",) . showValue <$>
-                 (args !? #kernel_size :: Maybe Int),
-               ("max_displacement",) . showValue <$>
-                 (args !? #max_displacement :: Maybe Int),
-               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),
-               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),
-               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),
-               ("is_multiply",) . showValue <$>
-                 (args !? #is_multiply :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data1",) <$> (args !? #data1 :: Maybe SymbolHandle),
-               ("data2",) <$> (args !? #data2 :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Correlation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Correlation(symbol)" = '[]
-
-_backward_Correlation ::
-                      forall args . Fullfilled "_backward_Correlation(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_Correlation(symbol)" args -> IO SymbolHandle
-_backward_Correlation name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Correlation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_IdentityAttachKLSparseReg(symbol)" = '[]
-
-_backward_IdentityAttachKLSparseReg ::
-                                    forall args .
-                                      Fullfilled "_backward_IdentityAttachKLSparseReg(symbol)"
-                                        args =>
-                                      String ->
-                                        ArgsHMap "_backward_IdentityAttachKLSparseReg(symbol)" args
-                                          -> IO SymbolHandle
-_backward_IdentityAttachKLSparseReg name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_MakeLoss(symbol)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_MakeLoss ::
-          forall args . Fullfilled "_MakeLoss(symbol)" args =>
-            String -> ArgsHMap "_MakeLoss(symbol)" args -> IO SymbolHandle
-_MakeLoss name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MakeLoss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_MakeLoss(symbol)" = '[]
-
-_backward_MakeLoss ::
-                   forall args . Fullfilled "_backward_MakeLoss(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_MakeLoss(symbol)" args -> IO SymbolHandle
-_backward_MakeLoss name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MakeLoss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SliceChannel(symbol)" = '[]
-
-_backward_SliceChannel ::
-                       forall args . Fullfilled "_backward_SliceChannel(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_SliceChannel(symbol)" args -> IO SymbolHandle
-_backward_SliceChannel name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SliceChannel"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_RNN(symbol)" =
-     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),
-        '("bidirectional", AttrOpt Bool),
-        '("mode",
-          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle),
-        '("parameters", AttrOpt SymbolHandle),
-        '("state", AttrOpt SymbolHandle),
-        '("state_cell", AttrOpt SymbolHandle)]
-
-_RNN ::
-     forall args . Fullfilled "_RNN(symbol)" args =>
-       String -> ArgsHMap "_RNN(symbol)" args -> IO SymbolHandle
-_RNN name args
-  = let scalarArgs
-          = catMaybes
-              [("state_size",) . showValue <$>
-                 (args !? #state_size :: Maybe Int),
-               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),
-               ("bidirectional",) . showValue <$>
-                 (args !? #bidirectional :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("state_outputs",) . showValue <$>
-                 (args !? #state_outputs :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("parameters",) <$> (args !? #parameters :: Maybe SymbolHandle),
-               ("state",) <$> (args !? #state :: Maybe SymbolHandle),
-               ("state_cell",) <$> (args !? #state_cell :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "RNN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_RNN(symbol)" = '[]
-
-_backward_RNN ::
-              forall args . Fullfilled "_backward_RNN(symbol)" args =>
-                String -> ArgsHMap "_backward_RNN(symbol)" args -> IO SymbolHandle
-_backward_RNN name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_RNN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Pooling_v1(symbol)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])),
-        '("global_pool", AttrOpt Bool),
-        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-_Pooling_v1 ::
-            forall args . Fullfilled "_Pooling_v1(symbol)" args =>
-              String -> ArgsHMap "_Pooling_v1(symbol)" args -> IO SymbolHandle
-_Pooling_v1 name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Pooling_v1(symbol)" = '[]
-
-_backward_Pooling_v1 ::
-                     forall args . Fullfilled "_backward_Pooling_v1(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_Pooling_v1(symbol)" args -> IO SymbolHandle
-_backward_Pooling_v1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_BatchNorm_v1(symbol)" = '[]
-
-_backward_BatchNorm_v1 ::
-                       forall args . Fullfilled "_backward_BatchNorm_v1(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_BatchNorm_v1(symbol)" args -> IO SymbolHandle
-_backward_BatchNorm_v1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SequenceMask(symbol)" =
-     '[ '("use_sequence_length", AttrOpt Bool),
-        '("value", AttrOpt Float), '("axis", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle),
-        '("sequence_length", AttrOpt SymbolHandle)]
-
-_SequenceMask ::
-              forall args . Fullfilled "_SequenceMask(symbol)" args =>
-                String -> ArgsHMap "_SequenceMask(symbol)" args -> IO SymbolHandle
-_SequenceMask name args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("value",) . showValue <$> (args !? #value :: Maybe Float),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceMask"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SequenceMask(symbol)" = '[]
-
-_backward_SequenceMask ::
-                       forall args . Fullfilled "_backward_SequenceMask(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_SequenceMask(symbol)" args -> IO SymbolHandle
-_backward_SequenceMask name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceMask"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_set_value(symbol)" =
-     '[ '("src", AttrOpt Float)]
-
-_set_value ::
-           forall args . Fullfilled "_set_value(symbol)" args =>
-             String -> ArgsHMap "_set_value(symbol)" args -> IO SymbolHandle
-_set_value name args
-  = let scalarArgs
-          = catMaybes
-              [("src",) . showValue <$> (args !? #src :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_set_value"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_imdecode(symbol)" =
-     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),
-        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),
-        '("c", AttrOpt Int), '("size", AttrOpt Int),
-        '("mean", AttrOpt SymbolHandle)]
-
-_imdecode ::
-          forall args . Fullfilled "_imdecode(symbol)" args =>
-            String -> ArgsHMap "_imdecode(symbol)" args -> IO SymbolHandle
-_imdecode name args
-  = let scalarArgs
-          = catMaybes
-              [("index",) . showValue <$> (args !? #index :: Maybe Int),
-               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),
-               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),
-               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),
-               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),
-               ("c",) . showValue <$> (args !? #c :: Maybe Int),
-               ("size",) . showValue <$> (args !? #size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("mean",) <$> (args !? #mean :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_imdecode"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
diff --git a/ops/1.4/MXNet/Base/Operators/NDArray.hs b/ops/1.4/MXNet/Base/Operators/NDArray.hs
deleted file mode 100644
--- a/ops/1.4/MXNet/Base/Operators/NDArray.hs
+++ /dev/null
@@ -1,21107 +0,0 @@
-module MXNet.Base.Operators.NDArray where
-import MXNet.Base.Raw
-import MXNet.Base.Spec.Operator
-import MXNet.Base.Spec.HMap
-import Data.Maybe (catMaybes, fromMaybe)
-
-type instance ParameterList "_CuDNNBatchNorm(ndarray)" =
-     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle),
-        '("moving_mean", AttrOpt NDArrayHandle),
-        '("moving_var", AttrOpt NDArrayHandle)]
-
-_CuDNNBatchNorm ::
-                forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args =>
-                  ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO [NDArrayHandle]
-_CuDNNBatchNorm args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CuDNNBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CuDNNBatchNorm_upd ::
-                    forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO ()
-_CuDNNBatchNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CuDNNBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_CuDNNBatchNorm(ndarray)" =
-     '[]
-
-_backward_CuDNNBatchNorm ::
-                         forall args .
-                           Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args =>
-                           ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_CuDNNBatchNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_CuDNNBatchNorm_upd ::
-                             forall args .
-                               Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args -> IO ()
-_backward_CuDNNBatchNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_multinomial(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_sample_multinomial ::
-                    forall args . Fullfilled "_sample_multinomial(ndarray)" args =>
-                      ArgsHMap "_sample_multinomial(ndarray)" args -> IO [NDArrayHandle]
-_sample_multinomial args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_multinomial_upd ::
-                        forall args . Fullfilled "_sample_multinomial(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_sample_multinomial(ndarray)" args -> IO ()
-_sample_multinomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sample_multinomial(ndarray)"
-     = '[]
-
-_backward_sample_multinomial ::
-                             forall args .
-                               Fullfilled "_backward_sample_multinomial(ndarray)" args =>
-                               ArgsHMap "_backward_sample_multinomial(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_backward_sample_multinomial args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sample_multinomial_upd ::
-                                 forall args .
-                                   Fullfilled "_backward_sample_multinomial(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_backward_sample_multinomial(ndarray)" args -> IO ()
-_backward_sample_multinomial_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_uniform(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("low", AttrOpt NDArrayHandle), '("high", AttrOpt NDArrayHandle)]
-
-_sample_uniform ::
-                forall args . Fullfilled "_sample_uniform(ndarray)" args =>
-                  ArgsHMap "_sample_uniform(ndarray)" args -> IO [NDArrayHandle]
-_sample_uniform args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("low",) <$> (args !? #low :: Maybe NDArrayHandle),
-               ("high",) <$> (args !? #high :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_uniform_upd ::
-                    forall args . Fullfilled "_sample_uniform(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_sample_uniform(ndarray)" args -> IO ()
-_sample_uniform_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("low",) <$> (args !? #low :: Maybe NDArrayHandle),
-               ("high",) <$> (args !? #high :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_normal(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt NDArrayHandle), '("sigma", AttrOpt NDArrayHandle)]
-
-_sample_normal ::
-               forall args . Fullfilled "_sample_normal(ndarray)" args =>
-                 ArgsHMap "_sample_normal(ndarray)" args -> IO [NDArrayHandle]
-_sample_normal args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_normal_upd ::
-                   forall args . Fullfilled "_sample_normal(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_sample_normal(ndarray)" args -> IO ()
-_sample_normal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_gamma(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("alpha", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_sample_gamma ::
-              forall args . Fullfilled "_sample_gamma(ndarray)" args =>
-                ArgsHMap "_sample_gamma(ndarray)" args -> IO [NDArrayHandle]
-_sample_gamma args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_gamma_upd ::
-                  forall args . Fullfilled "_sample_gamma(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_sample_gamma(ndarray)" args -> IO ()
-_sample_gamma_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_exponential(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt NDArrayHandle)]
-
-_sample_exponential ::
-                    forall args . Fullfilled "_sample_exponential(ndarray)" args =>
-                      ArgsHMap "_sample_exponential(ndarray)" args -> IO [NDArrayHandle]
-_sample_exponential args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_exponential_upd ::
-                        forall args . Fullfilled "_sample_exponential(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_sample_exponential(ndarray)" args -> IO ()
-_sample_exponential_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_poisson(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt NDArrayHandle)]
-
-_sample_poisson ::
-                forall args . Fullfilled "_sample_poisson(ndarray)" args =>
-                  ArgsHMap "_sample_poisson(ndarray)" args -> IO [NDArrayHandle]
-_sample_poisson args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_poisson_upd ::
-                    forall args . Fullfilled "_sample_poisson(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_sample_poisson(ndarray)" args -> IO ()
-_sample_poisson_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_negative_binomial(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("k", AttrOpt NDArrayHandle), '("p", AttrOpt NDArrayHandle)]
-
-_sample_negative_binomial ::
-                          forall args .
-                            Fullfilled "_sample_negative_binomial(ndarray)" args =>
-                            ArgsHMap "_sample_negative_binomial(ndarray)" args ->
-                              IO [NDArrayHandle]
-_sample_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("k",) <$> (args !? #k :: Maybe NDArrayHandle),
-               ("p",) <$> (args !? #p :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_negative_binomial_upd ::
-                              forall args .
-                                Fullfilled "_sample_negative_binomial(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_sample_negative_binomial(ndarray)" args -> IO ()
-_sample_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("k",) <$> (args !? #k :: Maybe NDArrayHandle),
-               ("p",) <$> (args !? #p :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_sample_generalized_negative_binomial(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt NDArrayHandle), '("alpha", AttrOpt NDArrayHandle)]
-
-_sample_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_sample_generalized_negative_binomial(ndarray)"
-                                          args =>
-                                        ArgsHMap "_sample_generalized_negative_binomial(ndarray)"
-                                          args
-                                          -> IO [NDArrayHandle]
-_sample_generalized_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_generalized_negative_binomial_upd ::
-                                          forall args .
-                                            Fullfilled
-                                              "_sample_generalized_negative_binomial(ndarray)"
-                                              args =>
-                                            [NDArrayHandle] ->
-                                              ArgsHMap
-                                                "_sample_generalized_negative_binomial(ndarray)"
-                                                args
-                                                -> IO ()
-_sample_generalized_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_unique_zipfian(ndarray)" =
-     '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])]
-
-_sample_unique_zipfian ::
-                       forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args =>
-                         ArgsHMap "_sample_unique_zipfian(ndarray)" args ->
-                           IO [NDArrayHandle]
-_sample_unique_zipfian args
-  = let scalarArgs
-          = catMaybes
-              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_unique_zipfian"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_unique_zipfian_upd ::
-                           forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_sample_unique_zipfian(ndarray)" args -> IO ()
-_sample_unique_zipfian_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_unique_zipfian"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_uniform(ndarray)" =
-     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_uniform ::
-                forall args . Fullfilled "_random_uniform(ndarray)" args =>
-                  ArgsHMap "_random_uniform(ndarray)" args -> IO [NDArrayHandle]
-_random_uniform args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_uniform_upd ::
-                    forall args . Fullfilled "_random_uniform(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_random_uniform(ndarray)" args -> IO ()
-_random_uniform_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_normal(ndarray)" =
-     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_normal ::
-               forall args . Fullfilled "_random_normal(ndarray)" args =>
-                 ArgsHMap "_random_normal(ndarray)" args -> IO [NDArrayHandle]
-_random_normal args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_normal_upd ::
-                   forall args . Fullfilled "_random_normal(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_random_normal(ndarray)" args -> IO ()
-_random_normal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_gamma(ndarray)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_gamma ::
-              forall args . Fullfilled "_random_gamma(ndarray)" args =>
-                ArgsHMap "_random_gamma(ndarray)" args -> IO [NDArrayHandle]
-_random_gamma args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_gamma_upd ::
-                  forall args . Fullfilled "_random_gamma(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_random_gamma(ndarray)" args -> IO ()
-_random_gamma_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_exponential(ndarray)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_exponential ::
-                    forall args . Fullfilled "_random_exponential(ndarray)" args =>
-                      ArgsHMap "_random_exponential(ndarray)" args -> IO [NDArrayHandle]
-_random_exponential args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_exponential_upd ::
-                        forall args . Fullfilled "_random_exponential(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_random_exponential(ndarray)" args -> IO ()
-_random_exponential_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_poisson(ndarray)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_poisson ::
-                forall args . Fullfilled "_random_poisson(ndarray)" args =>
-                  ArgsHMap "_random_poisson(ndarray)" args -> IO [NDArrayHandle]
-_random_poisson args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_poisson_upd ::
-                    forall args . Fullfilled "_random_poisson(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_random_poisson(ndarray)" args -> IO ()
-_random_poisson_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_negative_binomial(ndarray)" =
-     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_negative_binomial ::
-                          forall args .
-                            Fullfilled "_random_negative_binomial(ndarray)" args =>
-                            ArgsHMap "_random_negative_binomial(ndarray)" args ->
-                              IO [NDArrayHandle]
-_random_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_negative_binomial_upd ::
-                              forall args .
-                                Fullfilled "_random_negative_binomial(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_random_negative_binomial(ndarray)" args -> IO ()
-_random_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_random_generalized_negative_binomial(ndarray)" =
-     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_random_generalized_negative_binomial(ndarray)"
-                                          args =>
-                                        ArgsHMap "_random_generalized_negative_binomial(ndarray)"
-                                          args
-                                          -> IO [NDArrayHandle]
-_random_generalized_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_generalized_negative_binomial_upd ::
-                                          forall args .
-                                            Fullfilled
-                                              "_random_generalized_negative_binomial(ndarray)"
-                                              args =>
-                                            [NDArrayHandle] ->
-                                              ArgsHMap
-                                                "_random_generalized_negative_binomial(ndarray)"
-                                                args
-                                                -> IO ()
-_random_generalized_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_randint(ndarray)" =
-     '[ '("low", AttrReq Int), '("high", AttrReq Int),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype", AttrOpt (EnumType '["None", "int32", "int64"]))]
-
-_random_randint ::
-                forall args . Fullfilled "_random_randint(ndarray)" args =>
-                  ArgsHMap "_random_randint(ndarray)" args -> IO [NDArrayHandle]
-_random_randint args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Int),
-               ("high",) . showValue <$> (args !? #high :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_randint"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_randint_upd ::
-                    forall args . Fullfilled "_random_randint(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_random_randint(ndarray)" args -> IO ()
-_random_randint_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Int),
-               ("high",) . showValue <$> (args !? #high :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_randint"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_uniform_like(ndarray)" =
-     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_random_uniform_like ::
-                     forall args . Fullfilled "_random_uniform_like(ndarray)" args =>
-                       ArgsHMap "_random_uniform_like(ndarray)" args -> IO [NDArrayHandle]
-_random_uniform_like args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_uniform_like_upd ::
-                         forall args . Fullfilled "_random_uniform_like(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_random_uniform_like(ndarray)" args -> IO ()
-_random_uniform_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_normal_like(ndarray)" =
-     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_random_normal_like ::
-                    forall args . Fullfilled "_random_normal_like(ndarray)" args =>
-                      ArgsHMap "_random_normal_like(ndarray)" args -> IO [NDArrayHandle]
-_random_normal_like args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_normal_like_upd ::
-                        forall args . Fullfilled "_random_normal_like(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_random_normal_like(ndarray)" args -> IO ()
-_random_normal_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_gamma_like(ndarray)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_random_gamma_like ::
-                   forall args . Fullfilled "_random_gamma_like(ndarray)" args =>
-                     ArgsHMap "_random_gamma_like(ndarray)" args -> IO [NDArrayHandle]
-_random_gamma_like args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_gamma_like_upd ::
-                       forall args . Fullfilled "_random_gamma_like(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_random_gamma_like(ndarray)" args -> IO ()
-_random_gamma_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_exponential_like(ndarray)" =
-     '[ '("lam", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_random_exponential_like ::
-                         forall args .
-                           Fullfilled "_random_exponential_like(ndarray)" args =>
-                           ArgsHMap "_random_exponential_like(ndarray)" args ->
-                             IO [NDArrayHandle]
-_random_exponential_like args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_exponential_like_upd ::
-                             forall args .
-                               Fullfilled "_random_exponential_like(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_random_exponential_like(ndarray)" args -> IO ()
-_random_exponential_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_poisson_like(ndarray)" =
-     '[ '("lam", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_random_poisson_like ::
-                     forall args . Fullfilled "_random_poisson_like(ndarray)" args =>
-                       ArgsHMap "_random_poisson_like(ndarray)" args -> IO [NDArrayHandle]
-_random_poisson_like args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_poisson_like_upd ::
-                         forall args . Fullfilled "_random_poisson_like(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_random_poisson_like(ndarray)" args -> IO ()
-_random_poisson_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_random_negative_binomial_like(ndarray)" =
-     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_random_negative_binomial_like ::
-                               forall args .
-                                 Fullfilled "_random_negative_binomial_like(ndarray)" args =>
-                                 ArgsHMap "_random_negative_binomial_like(ndarray)" args ->
-                                   IO [NDArrayHandle]
-_random_negative_binomial_like args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_negative_binomial_like_upd ::
-                                   forall args .
-                                     Fullfilled "_random_negative_binomial_like(ndarray)" args =>
-                                     [NDArrayHandle] ->
-                                       ArgsHMap "_random_negative_binomial_like(ndarray)" args ->
-                                         IO ()
-_random_negative_binomial_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_random_generalized_negative_binomial_like(ndarray)"
-     =
-     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_random_generalized_negative_binomial_like ::
-                                           forall args .
-                                             Fullfilled
-                                               "_random_generalized_negative_binomial_like(ndarray)"
-                                               args =>
-                                             ArgsHMap
-                                               "_random_generalized_negative_binomial_like(ndarray)"
-                                               args
-                                               -> IO [NDArrayHandle]
-_random_generalized_negative_binomial_like args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_generalized_negative_binomial_like_upd ::
-                                               forall args .
-                                                 Fullfilled
-                                                   "_random_generalized_negative_binomial_like(ndarray)"
-                                                   args =>
-                                                 [NDArrayHandle] ->
-                                                   ArgsHMap
-                                                     "_random_generalized_negative_binomial_like(ndarray)"
-                                                     args
-                                                     -> IO ()
-_random_generalized_negative_binomial_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_shuffle(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_shuffle ::
-         forall args . Fullfilled "_shuffle(ndarray)" args =>
-           ArgsHMap "_shuffle(ndarray)" args -> IO [NDArrayHandle]
-_shuffle args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_shuffle"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_shuffle_upd ::
-             forall args . Fullfilled "_shuffle(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_shuffle(ndarray)" args -> IO ()
-_shuffle_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_shuffle"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Custom(ndarray)" = '[]
-
-_backward_Custom ::
-                 forall args . Fullfilled "_backward_Custom(ndarray)" args =>
-                   ArgsHMap "_backward_Custom(ndarray)" args -> IO [NDArrayHandle]
-_backward_Custom args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Custom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Custom_upd ::
-                     forall args . Fullfilled "_backward_Custom(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_Custom(ndarray)" args -> IO ()
-_backward_Custom_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Custom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_power(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_power ::
-                forall args . Fullfilled "broadcast_power(ndarray)" args =>
-                  ArgsHMap "broadcast_power(ndarray)" args -> IO [NDArrayHandle]
-broadcast_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_power_upd ::
-                    forall args . Fullfilled "broadcast_power(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "broadcast_power(ndarray)" args -> IO ()
-broadcast_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_power(ndarray)" =
-     '[]
-
-_backward_broadcast_power ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_power(ndarray)" args =>
-                            ArgsHMap "_backward_broadcast_power(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_broadcast_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_power_upd ::
-                              forall args .
-                                Fullfilled "_backward_broadcast_power(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_broadcast_power(ndarray)" args -> IO ()
-_backward_broadcast_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_maximum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_maximum ::
-                  forall args . Fullfilled "broadcast_maximum(ndarray)" args =>
-                    ArgsHMap "broadcast_maximum(ndarray)" args -> IO [NDArrayHandle]
-broadcast_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_maximum_upd ::
-                      forall args . Fullfilled "broadcast_maximum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "broadcast_maximum(ndarray)" args -> IO ()
-broadcast_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_maximum(ndarray)"
-     = '[]
-
-_backward_broadcast_maximum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_maximum(ndarray)" args =>
-                              ArgsHMap "_backward_broadcast_maximum(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_broadcast_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_maximum_upd ::
-                                forall args .
-                                  Fullfilled "_backward_broadcast_maximum(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> IO ()
-_backward_broadcast_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_minimum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_minimum ::
-                  forall args . Fullfilled "broadcast_minimum(ndarray)" args =>
-                    ArgsHMap "broadcast_minimum(ndarray)" args -> IO [NDArrayHandle]
-broadcast_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_minimum_upd ::
-                      forall args . Fullfilled "broadcast_minimum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "broadcast_minimum(ndarray)" args -> IO ()
-broadcast_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_minimum(ndarray)"
-     = '[]
-
-_backward_broadcast_minimum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_minimum(ndarray)" args =>
-                              ArgsHMap "_backward_broadcast_minimum(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_broadcast_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_minimum_upd ::
-                                forall args .
-                                  Fullfilled "_backward_broadcast_minimum(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> IO ()
-_backward_broadcast_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_hypot(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_hypot ::
-                forall args . Fullfilled "broadcast_hypot(ndarray)" args =>
-                  ArgsHMap "broadcast_hypot(ndarray)" args -> IO [NDArrayHandle]
-broadcast_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_hypot_upd ::
-                    forall args . Fullfilled "broadcast_hypot(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "broadcast_hypot(ndarray)" args -> IO ()
-broadcast_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_hypot(ndarray)" =
-     '[]
-
-_backward_broadcast_hypot ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_hypot(ndarray)" args =>
-                            ArgsHMap "_backward_broadcast_hypot(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_broadcast_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_hypot_upd ::
-                              forall args .
-                                Fullfilled "_backward_broadcast_hypot(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> IO ()
-_backward_broadcast_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_equal ::
-       forall args . Fullfilled "_equal(ndarray)" args =>
-         ArgsHMap "_equal(ndarray)" args -> IO [NDArrayHandle]
-_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_equal_upd ::
-           forall args . Fullfilled "_equal(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_equal(ndarray)" args -> IO ()
-_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_not_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_not_equal ::
-           forall args . Fullfilled "_not_equal(ndarray)" args =>
-             ArgsHMap "_not_equal(ndarray)" args -> IO [NDArrayHandle]
-_not_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_not_equal_upd ::
-               forall args . Fullfilled "_not_equal(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_not_equal(ndarray)" args -> IO ()
-_not_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_greater ::
-         forall args . Fullfilled "_greater(ndarray)" args =>
-           ArgsHMap "_greater(ndarray)" args -> IO [NDArrayHandle]
-_greater args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_upd ::
-             forall args . Fullfilled "_greater(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_greater(ndarray)" args -> IO ()
-_greater_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_greater_equal ::
-               forall args . Fullfilled "_greater_equal(ndarray)" args =>
-                 ArgsHMap "_greater_equal(ndarray)" args -> IO [NDArrayHandle]
-_greater_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_equal_upd ::
-                   forall args . Fullfilled "_greater_equal(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_greater_equal(ndarray)" args -> IO ()
-_greater_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_lesser ::
-        forall args . Fullfilled "_lesser(ndarray)" args =>
-          ArgsHMap "_lesser(ndarray)" args -> IO [NDArrayHandle]
-_lesser args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_upd ::
-            forall args . Fullfilled "_lesser(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_lesser(ndarray)" args -> IO ()
-_lesser_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_lesser_equal ::
-              forall args . Fullfilled "_lesser_equal(ndarray)" args =>
-                ArgsHMap "_lesser_equal(ndarray)" args -> IO [NDArrayHandle]
-_lesser_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_equal_upd ::
-                  forall args . Fullfilled "_lesser_equal(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_lesser_equal(ndarray)" args -> IO ()
-_lesser_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_and(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_logical_and ::
-             forall args . Fullfilled "_logical_and(ndarray)" args =>
-               ArgsHMap "_logical_and(ndarray)" args -> IO [NDArrayHandle]
-_logical_and args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_and_upd ::
-                 forall args . Fullfilled "_logical_and(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_logical_and(ndarray)" args -> IO ()
-_logical_and_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_or(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_logical_or ::
-            forall args . Fullfilled "_logical_or(ndarray)" args =>
-              ArgsHMap "_logical_or(ndarray)" args -> IO [NDArrayHandle]
-_logical_or args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_or_upd ::
-                forall args . Fullfilled "_logical_or(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_logical_or(ndarray)" args -> IO ()
-_logical_or_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_xor(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_logical_xor ::
-             forall args . Fullfilled "_logical_xor(ndarray)" args =>
-               ArgsHMap "_logical_xor(ndarray)" args -> IO [NDArrayHandle]
-_logical_xor args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_xor_upd ::
-                 forall args . Fullfilled "_logical_xor(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_logical_xor(ndarray)" args -> IO ()
-_logical_xor_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_power(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_power ::
-       forall args . Fullfilled "_power(ndarray)" args =>
-         ArgsHMap "_power(ndarray)" args -> IO [NDArrayHandle]
-_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_power_upd ::
-           forall args . Fullfilled "_power(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_power(ndarray)" args -> IO ()
-_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_power(ndarray)" = '[]
-
-_backward_power ::
-                forall args . Fullfilled "_backward_power(ndarray)" args =>
-                  ArgsHMap "_backward_power(ndarray)" args -> IO [NDArrayHandle]
-_backward_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_power_upd ::
-                    forall args . Fullfilled "_backward_power(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_power(ndarray)" args -> IO ()
-_backward_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_maximum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_maximum ::
-         forall args . Fullfilled "_maximum(ndarray)" args =>
-           ArgsHMap "_maximum(ndarray)" args -> IO [NDArrayHandle]
-_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_maximum_upd ::
-             forall args . Fullfilled "_maximum(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_maximum(ndarray)" args -> IO ()
-_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_maximum(ndarray)" = '[]
-
-_backward_maximum ::
-                  forall args . Fullfilled "_backward_maximum(ndarray)" args =>
-                    ArgsHMap "_backward_maximum(ndarray)" args -> IO [NDArrayHandle]
-_backward_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_maximum_upd ::
-                      forall args . Fullfilled "_backward_maximum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_maximum(ndarray)" args -> IO ()
-_backward_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_minimum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_minimum ::
-         forall args . Fullfilled "_minimum(ndarray)" args =>
-           ArgsHMap "_minimum(ndarray)" args -> IO [NDArrayHandle]
-_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_minimum_upd ::
-             forall args . Fullfilled "_minimum(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_minimum(ndarray)" args -> IO ()
-_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_minimum(ndarray)" = '[]
-
-_backward_minimum ::
-                  forall args . Fullfilled "_backward_minimum(ndarray)" args =>
-                    ArgsHMap "_backward_minimum(ndarray)" args -> IO [NDArrayHandle]
-_backward_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_minimum_upd ::
-                      forall args . Fullfilled "_backward_minimum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_minimum(ndarray)" args -> IO ()
-_backward_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_hypot(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_hypot ::
-       forall args . Fullfilled "_hypot(ndarray)" args =>
-         ArgsHMap "_hypot(ndarray)" args -> IO [NDArrayHandle]
-_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_hypot_upd ::
-           forall args . Fullfilled "_hypot(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_hypot(ndarray)" args -> IO ()
-_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_hypot(ndarray)" = '[]
-
-_backward_hypot ::
-                forall args . Fullfilled "_backward_hypot(ndarray)" args =>
-                  ArgsHMap "_backward_hypot(ndarray)" args -> IO [NDArrayHandle]
-_backward_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_hypot_upd ::
-                    forall args . Fullfilled "_backward_hypot(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_hypot(ndarray)" args -> IO ()
-_backward_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_square_sum(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-_square_sum ::
-            forall args . Fullfilled "_square_sum(ndarray)" args =>
-              ArgsHMap "_square_sum(ndarray)" args -> IO [NDArrayHandle]
-_square_sum args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_square_sum_upd ::
-                forall args . Fullfilled "_square_sum(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_square_sum(ndarray)" args -> IO ()
-_square_sum_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_square_sum(ndarray)" = '[]
-
-_backward_square_sum ::
-                     forall args . Fullfilled "_backward_square_sum(ndarray)" args =>
-                       ArgsHMap "_backward_square_sum(ndarray)" args -> IO [NDArrayHandle]
-_backward_square_sum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_square_sum_upd ::
-                         forall args . Fullfilled "_backward_square_sum(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_square_sum(ndarray)" args -> IO ()
-_backward_square_sum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "add_n(ndarray)" =
-     '[ '("args", AttrOpt [NDArrayHandle])]
-
-add_n ::
-      forall args . Fullfilled "add_n(ndarray)" args =>
-        ArgsHMap "add_n(ndarray)" args -> IO [NDArrayHandle]
-add_n args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "add_n"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-add_n_upd ::
-          forall args . Fullfilled "add_n(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "add_n(ndarray)" args -> IO ()
-add_n_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "add_n"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_zeros_without_dtype(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype", AttrOpt Int)]
-
-_zeros_without_dtype ::
-                     forall args . Fullfilled "_zeros_without_dtype(ndarray)" args =>
-                       ArgsHMap "_zeros_without_dtype(ndarray)" args -> IO [NDArrayHandle]
-_zeros_without_dtype args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros_without_dtype"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_zeros_without_dtype_upd ::
-                         forall args . Fullfilled "_zeros_without_dtype(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_zeros_without_dtype(ndarray)" args -> IO ()
-_zeros_without_dtype_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros_without_dtype"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_zeros(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_zeros ::
-       forall args . Fullfilled "_zeros(ndarray)" args =>
-         ArgsHMap "_zeros(ndarray)" args -> IO [NDArrayHandle]
-_zeros args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_zeros_upd ::
-           forall args . Fullfilled "_zeros(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_zeros(ndarray)" args -> IO ()
-_zeros_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_eye(ndarray)" =
-     '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_eye ::
-     forall args . Fullfilled "_eye(ndarray)" args =>
-       ArgsHMap "_eye(ndarray)" args -> IO [NDArrayHandle]
-_eye args
-  = let scalarArgs
-          = catMaybes
-              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),
-               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_eye"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_eye_upd ::
-         forall args . Fullfilled "_eye(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_eye(ndarray)" args -> IO ()
-_eye_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),
-               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_eye"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_ones(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_ones ::
-      forall args . Fullfilled "_ones(ndarray)" args =>
-        ArgsHMap "_ones(ndarray)" args -> IO [NDArrayHandle]
-_ones args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ones"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_ones_upd ::
-          forall args . Fullfilled "_ones(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_ones(ndarray)" args -> IO ()
-_ones_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ones"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_full(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("value", AttrReq Double)]
-
-_full ::
-      forall args . Fullfilled "_full(ndarray)" args =>
-        ArgsHMap "_full(ndarray)" args -> IO [NDArrayHandle]
-_full args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_full"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_full_upd ::
-          forall args . Fullfilled "_full(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_full(ndarray)" args -> IO ()
-_full_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_full"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_arange(ndarray)" =
-     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),
-        '("step", AttrOpt Double), '("repeat", AttrOpt Int),
-        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_arange ::
-        forall args . Fullfilled "_arange(ndarray)" args =>
-          ArgsHMap "_arange(ndarray)" args -> IO [NDArrayHandle]
-_arange args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("infer_range",) . showValue <$>
-                 (args !? #infer_range :: Maybe Bool),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_arange"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_arange_upd ::
-            forall args . Fullfilled "_arange(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_arange(ndarray)" args -> IO ()
-_arange_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("infer_range",) . showValue <$>
-                 (args !? #infer_range :: Maybe Bool),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_arange"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "zeros_like(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-zeros_like ::
-           forall args . Fullfilled "zeros_like(ndarray)" args =>
-             ArgsHMap "zeros_like(ndarray)" args -> IO [NDArrayHandle]
-zeros_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "zeros_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-zeros_like_upd ::
-               forall args . Fullfilled "zeros_like(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "zeros_like(ndarray)" args -> IO ()
-zeros_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "zeros_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ones_like(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-ones_like ::
-          forall args . Fullfilled "ones_like(ndarray)" args =>
-            ArgsHMap "ones_like(ndarray)" args -> IO [NDArrayHandle]
-ones_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ones_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ones_like_upd ::
-              forall args . Fullfilled "ones_like(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "ones_like(ndarray)" args -> IO ()
-ones_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ones_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_add(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_add ::
-              forall args . Fullfilled "broadcast_add(ndarray)" args =>
-                ArgsHMap "broadcast_add(ndarray)" args -> IO [NDArrayHandle]
-broadcast_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_add_upd ::
-                  forall args . Fullfilled "broadcast_add(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_add(ndarray)" args -> IO ()
-broadcast_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_add(ndarray)" =
-     '[]
-
-_backward_broadcast_add ::
-                        forall args . Fullfilled "_backward_broadcast_add(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_add(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_add_upd ::
-                            forall args . Fullfilled "_backward_broadcast_add(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_add(ndarray)" args -> IO ()
-_backward_broadcast_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_sub(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_sub ::
-              forall args . Fullfilled "broadcast_sub(ndarray)" args =>
-                ArgsHMap "broadcast_sub(ndarray)" args -> IO [NDArrayHandle]
-broadcast_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_sub_upd ::
-                  forall args . Fullfilled "broadcast_sub(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_sub(ndarray)" args -> IO ()
-broadcast_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_sub(ndarray)" =
-     '[]
-
-_backward_broadcast_sub ::
-                        forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_sub(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_sub_upd ::
-                            forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_sub(ndarray)" args -> IO ()
-_backward_broadcast_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_mul(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_mul ::
-              forall args . Fullfilled "broadcast_mul(ndarray)" args =>
-                ArgsHMap "broadcast_mul(ndarray)" args -> IO [NDArrayHandle]
-broadcast_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_mul_upd ::
-                  forall args . Fullfilled "broadcast_mul(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_mul(ndarray)" args -> IO ()
-broadcast_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_mul(ndarray)" =
-     '[]
-
-_backward_broadcast_mul ::
-                        forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_mul(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_mul_upd ::
-                            forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_mul(ndarray)" args -> IO ()
-_backward_broadcast_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_div(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_div ::
-              forall args . Fullfilled "broadcast_div(ndarray)" args =>
-                ArgsHMap "broadcast_div(ndarray)" args -> IO [NDArrayHandle]
-broadcast_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_div_upd ::
-                  forall args . Fullfilled "broadcast_div(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_div(ndarray)" args -> IO ()
-broadcast_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_div(ndarray)" =
-     '[]
-
-_backward_broadcast_div ::
-                        forall args . Fullfilled "_backward_broadcast_div(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_div(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_div_upd ::
-                            forall args . Fullfilled "_backward_broadcast_div(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_div(ndarray)" args -> IO ()
-_backward_broadcast_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_mod(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_mod ::
-              forall args . Fullfilled "broadcast_mod(ndarray)" args =>
-                ArgsHMap "broadcast_mod(ndarray)" args -> IO [NDArrayHandle]
-broadcast_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_mod_upd ::
-                  forall args . Fullfilled "broadcast_mod(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_mod(ndarray)" args -> IO ()
-broadcast_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_mod(ndarray)" =
-     '[]
-
-_backward_broadcast_mod ::
-                        forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_mod(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_mod_upd ::
-                            forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_mod(ndarray)" args -> IO ()
-_backward_broadcast_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_gemm(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),
-        '("axis", AttrOpt Int), '("_A", AttrOpt NDArrayHandle),
-        '("_B", AttrOpt NDArrayHandle), '("_C", AttrOpt NDArrayHandle)]
-
-_linalg_gemm ::
-             forall args . Fullfilled "_linalg_gemm(ndarray)" args =>
-               ArgsHMap "_linalg_gemm(ndarray)" args -> IO [NDArrayHandle]
-_linalg_gemm args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle),
-               ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_gemm_upd ::
-                 forall args . Fullfilled "_linalg_gemm(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_gemm(ndarray)" args -> IO ()
-_linalg_gemm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle),
-               ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_gemm(ndarray)" = '[]
-
-_backward_linalg_gemm ::
-                      forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_gemm(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_gemm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_gemm_upd ::
-                          forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_gemm(ndarray)" args -> IO ()
-_backward_linalg_gemm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_gemm2(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("axis", AttrOpt Int),
-        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)]
-
-_linalg_gemm2 ::
-              forall args . Fullfilled "_linalg_gemm2(ndarray)" args =>
-                ArgsHMap "_linalg_gemm2(ndarray)" args -> IO [NDArrayHandle]
-_linalg_gemm2 args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_gemm2_upd ::
-                  forall args . Fullfilled "_linalg_gemm2(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_gemm2(ndarray)" args -> IO ()
-_linalg_gemm2_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_gemm2(ndarray)" = '[]
-
-_backward_linalg_gemm2 ::
-                       forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_gemm2(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_gemm2 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_gemm2_upd ::
-                           forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> IO ()
-_backward_linalg_gemm2_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_potrf(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_potrf ::
-              forall args . Fullfilled "_linalg_potrf(ndarray)" args =>
-                ArgsHMap "_linalg_potrf(ndarray)" args -> IO [NDArrayHandle]
-_linalg_potrf args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_potrf_upd ::
-                  forall args . Fullfilled "_linalg_potrf(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_potrf(ndarray)" args -> IO ()
-_linalg_potrf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_potrf(ndarray)" = '[]
-
-_backward_linalg_potrf ::
-                       forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_potrf(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_potrf args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_potrf_upd ::
-                           forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_potrf(ndarray)" args -> IO ()
-_backward_linalg_potrf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_potri(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_potri ::
-              forall args . Fullfilled "_linalg_potri(ndarray)" args =>
-                ArgsHMap "_linalg_potri(ndarray)" args -> IO [NDArrayHandle]
-_linalg_potri args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_potri_upd ::
-                  forall args . Fullfilled "_linalg_potri(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_potri(ndarray)" args -> IO ()
-_linalg_potri_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_potri(ndarray)" = '[]
-
-_backward_linalg_potri ::
-                       forall args . Fullfilled "_backward_linalg_potri(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_potri(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_potri args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_potri_upd ::
-                           forall args . Fullfilled "_backward_linalg_potri(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_potri(ndarray)" args -> IO ()
-_backward_linalg_potri_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_trmm(ndarray)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)]
-
-_linalg_trmm ::
-             forall args . Fullfilled "_linalg_trmm(ndarray)" args =>
-               ArgsHMap "_linalg_trmm(ndarray)" args -> IO [NDArrayHandle]
-_linalg_trmm args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_trmm_upd ::
-                 forall args . Fullfilled "_linalg_trmm(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_trmm(ndarray)" args -> IO ()
-_linalg_trmm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_trmm(ndarray)" = '[]
-
-_backward_linalg_trmm ::
-                      forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_trmm(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_trmm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_trmm_upd ::
-                          forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_trmm(ndarray)" args -> IO ()
-_backward_linalg_trmm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_trsm(ndarray)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)]
-
-_linalg_trsm ::
-             forall args . Fullfilled "_linalg_trsm(ndarray)" args =>
-               ArgsHMap "_linalg_trsm(ndarray)" args -> IO [NDArrayHandle]
-_linalg_trsm args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_trsm_upd ::
-                 forall args . Fullfilled "_linalg_trsm(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_trsm(ndarray)" args -> IO ()
-_linalg_trsm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_trsm(ndarray)" = '[]
-
-_backward_linalg_trsm ::
-                      forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_trsm(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_trsm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_trsm_upd ::
-                          forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_trsm(ndarray)" args -> IO ()
-_backward_linalg_trsm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_sumlogdiag(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_sumlogdiag ::
-                   forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args =>
-                     ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO [NDArrayHandle]
-_linalg_sumlogdiag args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_sumlogdiag_upd ::
-                       forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO ()
-_linalg_sumlogdiag_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_sumlogdiag(ndarray)"
-     = '[]
-
-_backward_linalg_sumlogdiag ::
-                            forall args .
-                              Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args =>
-                              ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_linalg_sumlogdiag args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_sumlogdiag_upd ::
-                                forall args .
-                                  Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> IO ()
-_backward_linalg_sumlogdiag_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_syrk(ndarray)" =
-     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_syrk ::
-             forall args . Fullfilled "_linalg_syrk(ndarray)" args =>
-               ArgsHMap "_linalg_syrk(ndarray)" args -> IO [NDArrayHandle]
-_linalg_syrk args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_syrk_upd ::
-                 forall args . Fullfilled "_linalg_syrk(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_syrk(ndarray)" args -> IO ()
-_linalg_syrk_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_syrk(ndarray)" = '[]
-
-_backward_linalg_syrk ::
-                      forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_syrk(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_syrk args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_syrk_upd ::
-                          forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_syrk(ndarray)" args -> IO ()
-_backward_linalg_syrk_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_gelqf(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_gelqf ::
-              forall args . Fullfilled "_linalg_gelqf(ndarray)" args =>
-                ArgsHMap "_linalg_gelqf(ndarray)" args -> IO [NDArrayHandle]
-_linalg_gelqf args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_gelqf_upd ::
-                  forall args . Fullfilled "_linalg_gelqf(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_gelqf(ndarray)" args -> IO ()
-_linalg_gelqf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_gelqf(ndarray)" = '[]
-
-_backward_linalg_gelqf ::
-                       forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_gelqf(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_gelqf args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_gelqf_upd ::
-                           forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> IO ()
-_backward_linalg_gelqf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_syevd(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_syevd ::
-              forall args . Fullfilled "_linalg_syevd(ndarray)" args =>
-                ArgsHMap "_linalg_syevd(ndarray)" args -> IO [NDArrayHandle]
-_linalg_syevd args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_syevd_upd ::
-                  forall args . Fullfilled "_linalg_syevd(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_syevd(ndarray)" args -> IO ()
-_linalg_syevd_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_syevd(ndarray)" = '[]
-
-_backward_linalg_syevd ::
-                       forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_syevd(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_syevd args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_syevd_upd ::
-                           forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_syevd(ndarray)" args -> IO ()
-_backward_linalg_syevd_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_histogram(ndarray)" =
-     '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle), '("bins", AttrOpt NDArrayHandle)]
-
-_histogram ::
-           forall args . Fullfilled "_histogram(ndarray)" args =>
-             ArgsHMap "_histogram(ndarray)" args -> IO [NDArrayHandle]
-_histogram args
-  = let scalarArgs
-          = catMaybes
-              [("bin_cnt",) . showValue <$>
-                 (args !? #bin_cnt :: Maybe (Maybe Int)),
-               ("range",) . showValue <$> (args !? #range :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_histogram"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_histogram_upd ::
-               forall args . Fullfilled "_histogram(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_histogram(ndarray)" args -> IO ()
-_histogram_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("bin_cnt",) . showValue <$>
-                 (args !? #bin_cnt :: Maybe (Maybe Int)),
-               ("range",) . showValue <$> (args !? #range :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_histogram"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cast_storage(ndarray)" =
-     '[ '("stype",
-          AttrReq (EnumType '["csr", "default", "row_sparse"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-cast_storage ::
-             forall args . Fullfilled "cast_storage(ndarray)" args =>
-               ArgsHMap "cast_storage(ndarray)" args -> IO [NDArrayHandle]
-cast_storage args
-  = let scalarArgs
-          = catMaybes
-              [("stype",) . showValue <$>
-                 (args !? #stype ::
-                    Maybe (EnumType '["csr", "default", "row_sparse"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cast_storage"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cast_storage_upd ::
-                 forall args . Fullfilled "cast_storage(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "cast_storage(ndarray)" args -> IO ()
-cast_storage_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("stype",) . showValue <$>
-                 (args !? #stype ::
-                    Maybe (EnumType '["csr", "default", "row_sparse"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cast_storage"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_equal_scalar ::
-              forall args . Fullfilled "_equal_scalar(ndarray)" args =>
-                ArgsHMap "_equal_scalar(ndarray)" args -> IO [NDArrayHandle]
-_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_equal_scalar_upd ::
-                  forall args . Fullfilled "_equal_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_equal_scalar(ndarray)" args -> IO ()
-_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_not_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_not_equal_scalar ::
-                  forall args . Fullfilled "_not_equal_scalar(ndarray)" args =>
-                    ArgsHMap "_not_equal_scalar(ndarray)" args -> IO [NDArrayHandle]
-_not_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_not_equal_scalar_upd ::
-                      forall args . Fullfilled "_not_equal_scalar(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_not_equal_scalar(ndarray)" args -> IO ()
-_not_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_greater_scalar ::
-                forall args . Fullfilled "_greater_scalar(ndarray)" args =>
-                  ArgsHMap "_greater_scalar(ndarray)" args -> IO [NDArrayHandle]
-_greater_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_scalar_upd ::
-                    forall args . Fullfilled "_greater_scalar(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_greater_scalar(ndarray)" args -> IO ()
-_greater_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_greater_equal_scalar ::
-                      forall args . Fullfilled "_greater_equal_scalar(ndarray)" args =>
-                        ArgsHMap "_greater_equal_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_greater_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_equal_scalar_upd ::
-                          forall args . Fullfilled "_greater_equal_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_greater_equal_scalar(ndarray)" args -> IO ()
-_greater_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_lesser_scalar ::
-               forall args . Fullfilled "_lesser_scalar(ndarray)" args =>
-                 ArgsHMap "_lesser_scalar(ndarray)" args -> IO [NDArrayHandle]
-_lesser_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_scalar_upd ::
-                   forall args . Fullfilled "_lesser_scalar(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_lesser_scalar(ndarray)" args -> IO ()
-_lesser_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_lesser_equal_scalar ::
-                     forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args =>
-                       ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO [NDArrayHandle]
-_lesser_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_equal_scalar_upd ::
-                         forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO ()
-_lesser_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_and_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_logical_and_scalar ::
-                    forall args . Fullfilled "_logical_and_scalar(ndarray)" args =>
-                      ArgsHMap "_logical_and_scalar(ndarray)" args -> IO [NDArrayHandle]
-_logical_and_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_and_scalar_upd ::
-                        forall args . Fullfilled "_logical_and_scalar(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_logical_and_scalar(ndarray)" args -> IO ()
-_logical_and_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_or_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_logical_or_scalar ::
-                   forall args . Fullfilled "_logical_or_scalar(ndarray)" args =>
-                     ArgsHMap "_logical_or_scalar(ndarray)" args -> IO [NDArrayHandle]
-_logical_or_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_or_scalar_upd ::
-                       forall args . Fullfilled "_logical_or_scalar(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_logical_or_scalar(ndarray)" args -> IO ()
-_logical_or_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_xor_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_logical_xor_scalar ::
-                    forall args . Fullfilled "_logical_xor_scalar(ndarray)" args =>
-                      ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO [NDArrayHandle]
-_logical_xor_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_xor_scalar_upd ::
-                        forall args . Fullfilled "_logical_xor_scalar(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO ()
-_logical_xor_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "relu(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-relu ::
-     forall args . Fullfilled "relu(ndarray)" args =>
-       ArgsHMap "relu(ndarray)" args -> IO [NDArrayHandle]
-relu args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-relu_upd ::
-         forall args . Fullfilled "relu(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "relu(ndarray)" args -> IO ()
-relu_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_relu(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_relu ::
-               forall args . Fullfilled "_backward_relu(ndarray)" args =>
-                 ArgsHMap "_backward_relu(ndarray)" args -> IO [NDArrayHandle]
-_backward_relu args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_relu_upd ::
-                   forall args . Fullfilled "_backward_relu(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_relu(ndarray)" args -> IO ()
-_backward_relu_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sigmoid(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sigmoid ::
-        forall args . Fullfilled "sigmoid(ndarray)" args =>
-          ArgsHMap "sigmoid(ndarray)" args -> IO [NDArrayHandle]
-sigmoid args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sigmoid_upd ::
-            forall args . Fullfilled "sigmoid(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "sigmoid(ndarray)" args -> IO ()
-sigmoid_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sigmoid(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sigmoid ::
-                  forall args . Fullfilled "_backward_sigmoid(ndarray)" args =>
-                    ArgsHMap "_backward_sigmoid(ndarray)" args -> IO [NDArrayHandle]
-_backward_sigmoid args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sigmoid_upd ::
-                      forall args . Fullfilled "_backward_sigmoid(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_sigmoid(ndarray)" args -> IO ()
-_backward_sigmoid_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "hard_sigmoid(ndarray)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-hard_sigmoid ::
-             forall args . Fullfilled "hard_sigmoid(ndarray)" args =>
-               ArgsHMap "hard_sigmoid(ndarray)" args -> IO [NDArrayHandle]
-hard_sigmoid args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "hard_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-hard_sigmoid_upd ::
-                 forall args . Fullfilled "hard_sigmoid(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "hard_sigmoid(ndarray)" args -> IO ()
-hard_sigmoid_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "hard_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_hard_sigmoid(ndarray)" = '[]
-
-_backward_hard_sigmoid ::
-                       forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args =>
-                         ArgsHMap "_backward_hard_sigmoid(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_hard_sigmoid args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hard_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_hard_sigmoid_upd ::
-                           forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_hard_sigmoid(ndarray)" args -> IO ()
-_backward_hard_sigmoid_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hard_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "softsign(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-softsign ::
-         forall args . Fullfilled "softsign(ndarray)" args =>
-           ArgsHMap "softsign(ndarray)" args -> IO [NDArrayHandle]
-softsign args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softsign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-softsign_upd ::
-             forall args . Fullfilled "softsign(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "softsign(ndarray)" args -> IO ()
-softsign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softsign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_softsign(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_softsign ::
-                   forall args . Fullfilled "_backward_softsign(ndarray)" args =>
-                     ArgsHMap "_backward_softsign(ndarray)" args -> IO [NDArrayHandle]
-_backward_softsign args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softsign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_softsign_upd ::
-                       forall args . Fullfilled "_backward_softsign(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_softsign(ndarray)" args -> IO ()
-_backward_softsign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softsign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_copy(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_copy ::
-      forall args . Fullfilled "_copy(ndarray)" args =>
-        ArgsHMap "_copy(ndarray)" args -> IO [NDArrayHandle]
-_copy args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_copy_upd ::
-          forall args . Fullfilled "_copy(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_copy(ndarray)" args -> IO ()
-_copy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_copy(ndarray)" = '[]
-
-_backward_copy ::
-               forall args . Fullfilled "_backward_copy(ndarray)" args =>
-                 ArgsHMap "_backward_copy(ndarray)" args -> IO [NDArrayHandle]
-_backward_copy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_copy_upd ::
-                   forall args . Fullfilled "_backward_copy(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_copy(ndarray)" args -> IO ()
-_backward_copy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BlockGrad(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_BlockGrad ::
-           forall args . Fullfilled "_BlockGrad(ndarray)" args =>
-             ArgsHMap "_BlockGrad(ndarray)" args -> IO [NDArrayHandle]
-_BlockGrad args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BlockGrad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BlockGrad_upd ::
-               forall args . Fullfilled "_BlockGrad(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_BlockGrad(ndarray)" args -> IO ()
-_BlockGrad_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BlockGrad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "make_loss(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-make_loss ::
-          forall args . Fullfilled "make_loss(ndarray)" args =>
-            ArgsHMap "make_loss(ndarray)" args -> IO [NDArrayHandle]
-make_loss args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "make_loss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-make_loss_upd ::
-              forall args . Fullfilled "make_loss(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "make_loss(ndarray)" args -> IO ()
-make_loss_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "make_loss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_identity_with_attr_like_rhs(ndarray)"
-     =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_identity_with_attr_like_rhs ::
-                             forall args .
-                               Fullfilled "_identity_with_attr_like_rhs(ndarray)" args =>
-                               ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_identity_with_attr_like_rhs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_identity_with_attr_like_rhs_upd ::
-                                 forall args .
-                                   Fullfilled "_identity_with_attr_like_rhs(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> IO ()
-_identity_with_attr_like_rhs_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "reshape_like(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-reshape_like ::
-             forall args . Fullfilled "reshape_like(ndarray)" args =>
-               ArgsHMap "reshape_like(ndarray)" args -> IO [NDArrayHandle]
-reshape_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reshape_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-reshape_like_upd ::
-                 forall args . Fullfilled "reshape_like(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "reshape_like(ndarray)" args -> IO ()
-reshape_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reshape_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "shape_array(ndarray)" =
-     '[ '("lhs_begin", AttrOpt (Maybe Int)),
-        '("lhs_end", AttrOpt (Maybe Int)),
-        '("rhs_begin", AttrOpt (Maybe Int)),
-        '("rhs_end", AttrOpt (Maybe Int)),
-        '("data", AttrOpt NDArrayHandle)]
-
-shape_array ::
-            forall args . Fullfilled "shape_array(ndarray)" args =>
-              ArgsHMap "shape_array(ndarray)" args -> IO [NDArrayHandle]
-shape_array args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_begin",) . showValue <$>
-                 (args !? #lhs_begin :: Maybe (Maybe Int)),
-               ("lhs_end",) . showValue <$>
-                 (args !? #lhs_end :: Maybe (Maybe Int)),
-               ("rhs_begin",) . showValue <$>
-                 (args !? #rhs_begin :: Maybe (Maybe Int)),
-               ("rhs_end",) . showValue <$>
-                 (args !? #rhs_end :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "shape_array"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-shape_array_upd ::
-                forall args . Fullfilled "shape_array(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "shape_array(ndarray)" args -> IO ()
-shape_array_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_begin",) . showValue <$>
-                 (args !? #lhs_begin :: Maybe (Maybe Int)),
-               ("lhs_end",) . showValue <$>
-                 (args !? #lhs_end :: Maybe (Maybe Int)),
-               ("rhs_begin",) . showValue <$>
-                 (args !? #rhs_begin :: Maybe (Maybe Int)),
-               ("rhs_end",) . showValue <$>
-                 (args !? #rhs_end :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "shape_array"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "size_array(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-size_array ::
-           forall args . Fullfilled "size_array(ndarray)" args =>
-             ArgsHMap "size_array(ndarray)" args -> IO [NDArrayHandle]
-size_array args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "size_array"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-size_array_upd ::
-               forall args . Fullfilled "size_array(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "size_array(ndarray)" args -> IO ()
-size_array_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "size_array"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Cast(ndarray)" =
-     '[ '("dtype",
-          AttrReq
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Cast ::
-      forall args . Fullfilled "_Cast(ndarray)" args =>
-        ArgsHMap "_Cast(ndarray)" args -> IO [NDArrayHandle]
-_Cast args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Cast_upd ::
-          forall args . Fullfilled "_Cast(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_Cast(ndarray)" args -> IO ()
-_Cast_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cast(ndarray)" = '[]
-
-_backward_cast ::
-               forall args . Fullfilled "_backward_cast(ndarray)" args =>
-                 ArgsHMap "_backward_cast(ndarray)" args -> IO [NDArrayHandle]
-_backward_cast args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cast_upd ::
-                   forall args . Fullfilled "_backward_cast(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cast(ndarray)" args -> IO ()
-_backward_cast_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "negative(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-negative ::
-         forall args . Fullfilled "negative(ndarray)" args =>
-           ArgsHMap "negative(ndarray)" args -> IO [NDArrayHandle]
-negative args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "negative"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-negative_upd ::
-             forall args . Fullfilled "negative(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "negative(ndarray)" args -> IO ()
-negative_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "negative"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "reciprocal(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-reciprocal ::
-           forall args . Fullfilled "reciprocal(ndarray)" args =>
-             ArgsHMap "reciprocal(ndarray)" args -> IO [NDArrayHandle]
-reciprocal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-reciprocal_upd ::
-               forall args . Fullfilled "reciprocal(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "reciprocal(ndarray)" args -> IO ()
-reciprocal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_reciprocal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_reciprocal ::
-                     forall args . Fullfilled "_backward_reciprocal(ndarray)" args =>
-                       ArgsHMap "_backward_reciprocal(ndarray)" args -> IO [NDArrayHandle]
-_backward_reciprocal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_reciprocal_upd ::
-                         forall args . Fullfilled "_backward_reciprocal(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_reciprocal(ndarray)" args -> IO ()
-_backward_reciprocal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "abs(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-abs ::
-    forall args . Fullfilled "abs(ndarray)" args =>
-      ArgsHMap "abs(ndarray)" args -> IO [NDArrayHandle]
-abs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-abs_upd ::
-        forall args . Fullfilled "abs(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "abs(ndarray)" args -> IO ()
-abs_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_abs(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_abs ::
-              forall args . Fullfilled "_backward_abs(ndarray)" args =>
-                ArgsHMap "_backward_abs(ndarray)" args -> IO [NDArrayHandle]
-_backward_abs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_abs_upd ::
-                  forall args . Fullfilled "_backward_abs(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_abs(ndarray)" args -> IO ()
-_backward_abs_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sign(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sign ::
-     forall args . Fullfilled "sign(ndarray)" args =>
-       ArgsHMap "sign(ndarray)" args -> IO [NDArrayHandle]
-sign args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sign_upd ::
-         forall args . Fullfilled "sign(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sign(ndarray)" args -> IO ()
-sign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sign(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sign ::
-               forall args . Fullfilled "_backward_sign(ndarray)" args =>
-                 ArgsHMap "_backward_sign(ndarray)" args -> IO [NDArrayHandle]
-_backward_sign args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sign_upd ::
-                   forall args . Fullfilled "_backward_sign(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_sign(ndarray)" args -> IO ()
-_backward_sign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "round(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-round ::
-      forall args . Fullfilled "round(ndarray)" args =>
-        ArgsHMap "round(ndarray)" args -> IO [NDArrayHandle]
-round args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "round"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-round_upd ::
-          forall args . Fullfilled "round(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "round(ndarray)" args -> IO ()
-round_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "round"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rint(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-rint ::
-     forall args . Fullfilled "rint(ndarray)" args =>
-       ArgsHMap "rint(ndarray)" args -> IO [NDArrayHandle]
-rint args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rint"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rint_upd ::
-         forall args . Fullfilled "rint(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "rint(ndarray)" args -> IO ()
-rint_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rint"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ceil(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-ceil ::
-     forall args . Fullfilled "ceil(ndarray)" args =>
-       ArgsHMap "ceil(ndarray)" args -> IO [NDArrayHandle]
-ceil args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ceil"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ceil_upd ::
-         forall args . Fullfilled "ceil(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "ceil(ndarray)" args -> IO ()
-ceil_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ceil"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "floor(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-floor ::
-      forall args . Fullfilled "floor(ndarray)" args =>
-        ArgsHMap "floor(ndarray)" args -> IO [NDArrayHandle]
-floor args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "floor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-floor_upd ::
-          forall args . Fullfilled "floor(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "floor(ndarray)" args -> IO ()
-floor_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "floor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "trunc(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-trunc ::
-      forall args . Fullfilled "trunc(ndarray)" args =>
-        ArgsHMap "trunc(ndarray)" args -> IO [NDArrayHandle]
-trunc args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "trunc"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-trunc_upd ::
-          forall args . Fullfilled "trunc(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "trunc(ndarray)" args -> IO ()
-trunc_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "trunc"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "fix(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-fix ::
-    forall args . Fullfilled "fix(ndarray)" args =>
-      ArgsHMap "fix(ndarray)" args -> IO [NDArrayHandle]
-fix args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fix"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-fix_upd ::
-        forall args . Fullfilled "fix(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "fix(ndarray)" args -> IO ()
-fix_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fix"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "square(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-square ::
-       forall args . Fullfilled "square(ndarray)" args =>
-         ArgsHMap "square(ndarray)" args -> IO [NDArrayHandle]
-square args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-square_upd ::
-           forall args . Fullfilled "square(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "square(ndarray)" args -> IO ()
-square_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_square(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_square ::
-                 forall args . Fullfilled "_backward_square(ndarray)" args =>
-                   ArgsHMap "_backward_square(ndarray)" args -> IO [NDArrayHandle]
-_backward_square args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_square_upd ::
-                     forall args . Fullfilled "_backward_square(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_square(ndarray)" args -> IO ()
-_backward_square_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sqrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sqrt ::
-     forall args . Fullfilled "sqrt(ndarray)" args =>
-       ArgsHMap "sqrt(ndarray)" args -> IO [NDArrayHandle]
-sqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sqrt_upd ::
-         forall args . Fullfilled "sqrt(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sqrt(ndarray)" args -> IO ()
-sqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sqrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sqrt ::
-               forall args . Fullfilled "_backward_sqrt(ndarray)" args =>
-                 ArgsHMap "_backward_sqrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_sqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sqrt_upd ::
-                   forall args . Fullfilled "_backward_sqrt(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_sqrt(ndarray)" args -> IO ()
-_backward_sqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rsqrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-rsqrt ::
-      forall args . Fullfilled "rsqrt(ndarray)" args =>
-        ArgsHMap "rsqrt(ndarray)" args -> IO [NDArrayHandle]
-rsqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rsqrt_upd ::
-          forall args . Fullfilled "rsqrt(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "rsqrt(ndarray)" args -> IO ()
-rsqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rsqrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rsqrt ::
-                forall args . Fullfilled "_backward_rsqrt(ndarray)" args =>
-                  ArgsHMap "_backward_rsqrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_rsqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rsqrt_upd ::
-                    forall args . Fullfilled "_backward_rsqrt(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_rsqrt(ndarray)" args -> IO ()
-_backward_rsqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cbrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-cbrt ::
-     forall args . Fullfilled "cbrt(ndarray)" args =>
-       ArgsHMap "cbrt(ndarray)" args -> IO [NDArrayHandle]
-cbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cbrt_upd ::
-         forall args . Fullfilled "cbrt(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "cbrt(ndarray)" args -> IO ()
-cbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cbrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_cbrt ::
-               forall args . Fullfilled "_backward_cbrt(ndarray)" args =>
-                 ArgsHMap "_backward_cbrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_cbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cbrt_upd ::
-                   forall args . Fullfilled "_backward_cbrt(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cbrt(ndarray)" args -> IO ()
-_backward_cbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "erf(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-erf ::
-    forall args . Fullfilled "erf(ndarray)" args =>
-      ArgsHMap "erf(ndarray)" args -> IO [NDArrayHandle]
-erf args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "erf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-erf_upd ::
-        forall args . Fullfilled "erf(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "erf(ndarray)" args -> IO ()
-erf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "erf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_erf(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_erf ::
-              forall args . Fullfilled "_backward_erf(ndarray)" args =>
-                ArgsHMap "_backward_erf(ndarray)" args -> IO [NDArrayHandle]
-_backward_erf args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_erf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_erf_upd ::
-                  forall args . Fullfilled "_backward_erf(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_erf(ndarray)" args -> IO ()
-_backward_erf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_erf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rcbrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-rcbrt ::
-      forall args . Fullfilled "rcbrt(ndarray)" args =>
-        ArgsHMap "rcbrt(ndarray)" args -> IO [NDArrayHandle]
-rcbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rcbrt_upd ::
-          forall args . Fullfilled "rcbrt(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "rcbrt(ndarray)" args -> IO ()
-rcbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rcbrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rcbrt ::
-                forall args . Fullfilled "_backward_rcbrt(ndarray)" args =>
-                  ArgsHMap "_backward_rcbrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_rcbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rcbrt_upd ::
-                    forall args . Fullfilled "_backward_rcbrt(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_rcbrt(ndarray)" args -> IO ()
-_backward_rcbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "exp(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-exp ::
-    forall args . Fullfilled "exp(ndarray)" args =>
-      ArgsHMap "exp(ndarray)" args -> IO [NDArrayHandle]
-exp args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "exp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-exp_upd ::
-        forall args . Fullfilled "exp(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "exp(ndarray)" args -> IO ()
-exp_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "exp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log ::
-    forall args . Fullfilled "log(ndarray)" args =>
-      ArgsHMap "log(ndarray)" args -> IO [NDArrayHandle]
-log args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log_upd ::
-        forall args . Fullfilled "log(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "log(ndarray)" args -> IO ()
-log_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log10(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log10 ::
-      forall args . Fullfilled "log10(ndarray)" args =>
-        ArgsHMap "log10(ndarray)" args -> IO [NDArrayHandle]
-log10 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log10_upd ::
-          forall args . Fullfilled "log10(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "log10(ndarray)" args -> IO ()
-log10_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log2(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log2 ::
-     forall args . Fullfilled "log2(ndarray)" args =>
-       ArgsHMap "log2(ndarray)" args -> IO [NDArrayHandle]
-log2 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log2_upd ::
-         forall args . Fullfilled "log2(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "log2(ndarray)" args -> IO ()
-log2_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log ::
-              forall args . Fullfilled "_backward_log(ndarray)" args =>
-                ArgsHMap "_backward_log(ndarray)" args -> IO [NDArrayHandle]
-_backward_log args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log_upd ::
-                  forall args . Fullfilled "_backward_log(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_log(ndarray)" args -> IO ()
-_backward_log_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log10(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log10 ::
-                forall args . Fullfilled "_backward_log10(ndarray)" args =>
-                  ArgsHMap "_backward_log10(ndarray)" args -> IO [NDArrayHandle]
-_backward_log10 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log10_upd ::
-                    forall args . Fullfilled "_backward_log10(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_log10(ndarray)" args -> IO ()
-_backward_log10_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log2(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log2 ::
-               forall args . Fullfilled "_backward_log2(ndarray)" args =>
-                 ArgsHMap "_backward_log2(ndarray)" args -> IO [NDArrayHandle]
-_backward_log2 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log2_upd ::
-                   forall args . Fullfilled "_backward_log2(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_log2(ndarray)" args -> IO ()
-_backward_log2_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log1p(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log1p ::
-      forall args . Fullfilled "log1p(ndarray)" args =>
-        ArgsHMap "log1p(ndarray)" args -> IO [NDArrayHandle]
-log1p args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log1p_upd ::
-          forall args . Fullfilled "log1p(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "log1p(ndarray)" args -> IO ()
-log1p_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log1p(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log1p ::
-                forall args . Fullfilled "_backward_log1p(ndarray)" args =>
-                  ArgsHMap "_backward_log1p(ndarray)" args -> IO [NDArrayHandle]
-_backward_log1p args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log1p_upd ::
-                    forall args . Fullfilled "_backward_log1p(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_log1p(ndarray)" args -> IO ()
-_backward_log1p_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "expm1(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-expm1 ::
-      forall args . Fullfilled "expm1(ndarray)" args =>
-        ArgsHMap "expm1(ndarray)" args -> IO [NDArrayHandle]
-expm1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-expm1_upd ::
-          forall args . Fullfilled "expm1(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "expm1(ndarray)" args -> IO ()
-expm1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_expm1(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_expm1 ::
-                forall args . Fullfilled "_backward_expm1(ndarray)" args =>
-                  ArgsHMap "_backward_expm1(ndarray)" args -> IO [NDArrayHandle]
-_backward_expm1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_expm1_upd ::
-                    forall args . Fullfilled "_backward_expm1(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_expm1(ndarray)" args -> IO ()
-_backward_expm1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "gamma(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-gamma ::
-      forall args . Fullfilled "gamma(ndarray)" args =>
-        ArgsHMap "gamma(ndarray)" args -> IO [NDArrayHandle]
-gamma args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-gamma_upd ::
-          forall args . Fullfilled "gamma(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "gamma(ndarray)" args -> IO ()
-gamma_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_gamma(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_gamma ::
-                forall args . Fullfilled "_backward_gamma(ndarray)" args =>
-                  ArgsHMap "_backward_gamma(ndarray)" args -> IO [NDArrayHandle]
-_backward_gamma args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_gamma_upd ::
-                    forall args . Fullfilled "_backward_gamma(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_gamma(ndarray)" args -> IO ()
-_backward_gamma_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "gammaln(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-gammaln ::
-        forall args . Fullfilled "gammaln(ndarray)" args =>
-          ArgsHMap "gammaln(ndarray)" args -> IO [NDArrayHandle]
-gammaln args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-gammaln_upd ::
-            forall args . Fullfilled "gammaln(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "gammaln(ndarray)" args -> IO ()
-gammaln_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_gammaln(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_gammaln ::
-                  forall args . Fullfilled "_backward_gammaln(ndarray)" args =>
-                    ArgsHMap "_backward_gammaln(ndarray)" args -> IO [NDArrayHandle]
-_backward_gammaln args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_gammaln_upd ::
-                      forall args . Fullfilled "_backward_gammaln(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_gammaln(ndarray)" args -> IO ()
-_backward_gammaln_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "logical_not(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-logical_not ::
-            forall args . Fullfilled "logical_not(ndarray)" args =>
-              ArgsHMap "logical_not(ndarray)" args -> IO [NDArrayHandle]
-logical_not args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "logical_not"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-logical_not_upd ::
-                forall args . Fullfilled "logical_not(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "logical_not(ndarray)" args -> IO ()
-logical_not_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "logical_not"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sum(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-sum ::
-    forall args . Fullfilled "sum(ndarray)" args =>
-      ArgsHMap "sum(ndarray)" args -> IO [NDArrayHandle]
-sum args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sum_upd ::
-        forall args . Fullfilled "sum(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "sum(ndarray)" args -> IO ()
-sum_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sum(ndarray)" = '[]
-
-_backward_sum ::
-              forall args . Fullfilled "_backward_sum(ndarray)" args =>
-                ArgsHMap "_backward_sum(ndarray)" args -> IO [NDArrayHandle]
-_backward_sum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sum_upd ::
-                  forall args . Fullfilled "_backward_sum(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_sum(ndarray)" args -> IO ()
-_backward_sum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "mean(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-mean ::
-     forall args . Fullfilled "mean(ndarray)" args =>
-       ArgsHMap "mean(ndarray)" args -> IO [NDArrayHandle]
-mean args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-mean_upd ::
-         forall args . Fullfilled "mean(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "mean(ndarray)" args -> IO ()
-mean_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mean(ndarray)" = '[]
-
-_backward_mean ::
-               forall args . Fullfilled "_backward_mean(ndarray)" args =>
-                 ArgsHMap "_backward_mean(ndarray)" args -> IO [NDArrayHandle]
-_backward_mean args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mean_upd ::
-                   forall args . Fullfilled "_backward_mean(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_mean(ndarray)" args -> IO ()
-_backward_mean_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "prod(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-prod ::
-     forall args . Fullfilled "prod(ndarray)" args =>
-       ArgsHMap "prod(ndarray)" args -> IO [NDArrayHandle]
-prod args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-prod_upd ::
-         forall args . Fullfilled "prod(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "prod(ndarray)" args -> IO ()
-prod_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_prod(ndarray)" = '[]
-
-_backward_prod ::
-               forall args . Fullfilled "_backward_prod(ndarray)" args =>
-                 ArgsHMap "_backward_prod(ndarray)" args -> IO [NDArrayHandle]
-_backward_prod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_prod_upd ::
-                   forall args . Fullfilled "_backward_prod(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_prod(ndarray)" args -> IO ()
-_backward_prod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "nansum(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-nansum ::
-       forall args . Fullfilled "nansum(ndarray)" args =>
-         ArgsHMap "nansum(ndarray)" args -> IO [NDArrayHandle]
-nansum args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-nansum_upd ::
-           forall args . Fullfilled "nansum(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "nansum(ndarray)" args -> IO ()
-nansum_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_nansum(ndarray)" = '[]
-
-_backward_nansum ::
-                 forall args . Fullfilled "_backward_nansum(ndarray)" args =>
-                   ArgsHMap "_backward_nansum(ndarray)" args -> IO [NDArrayHandle]
-_backward_nansum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_nansum_upd ::
-                     forall args . Fullfilled "_backward_nansum(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_nansum(ndarray)" args -> IO ()
-_backward_nansum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "nanprod(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-nanprod ::
-        forall args . Fullfilled "nanprod(ndarray)" args =>
-          ArgsHMap "nanprod(ndarray)" args -> IO [NDArrayHandle]
-nanprod args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-nanprod_upd ::
-            forall args . Fullfilled "nanprod(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "nanprod(ndarray)" args -> IO ()
-nanprod_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_nanprod(ndarray)" = '[]
-
-_backward_nanprod ::
-                  forall args . Fullfilled "_backward_nanprod(ndarray)" args =>
-                    ArgsHMap "_backward_nanprod(ndarray)" args -> IO [NDArrayHandle]
-_backward_nanprod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_nanprod_upd ::
-                      forall args . Fullfilled "_backward_nanprod(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_nanprod(ndarray)" args -> IO ()
-_backward_nanprod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "max(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-max ::
-    forall args . Fullfilled "max(ndarray)" args =>
-      ArgsHMap "max(ndarray)" args -> IO [NDArrayHandle]
-max args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-max_upd ::
-        forall args . Fullfilled "max(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "max(ndarray)" args -> IO ()
-max_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_max(ndarray)" = '[]
-
-_backward_max ::
-              forall args . Fullfilled "_backward_max(ndarray)" args =>
-                ArgsHMap "_backward_max(ndarray)" args -> IO [NDArrayHandle]
-_backward_max args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_max_upd ::
-                  forall args . Fullfilled "_backward_max(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_max(ndarray)" args -> IO ()
-_backward_max_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "min(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-min ::
-    forall args . Fullfilled "min(ndarray)" args =>
-      ArgsHMap "min(ndarray)" args -> IO [NDArrayHandle]
-min args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-min_upd ::
-        forall args . Fullfilled "min(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "min(ndarray)" args -> IO ()
-min_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_min(ndarray)" = '[]
-
-_backward_min ::
-              forall args . Fullfilled "_backward_min(ndarray)" args =>
-                ArgsHMap "_backward_min(ndarray)" args -> IO [NDArrayHandle]
-_backward_min args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_min_upd ::
-                  forall args . Fullfilled "_backward_min(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_min(ndarray)" args -> IO ()
-_backward_min_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_axis(ndarray)" =
-     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-broadcast_axis ::
-               forall args . Fullfilled "broadcast_axis(ndarray)" args =>
-                 ArgsHMap "broadcast_axis(ndarray)" args -> IO [NDArrayHandle]
-broadcast_axis args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_axis_upd ::
-                   forall args . Fullfilled "broadcast_axis(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "broadcast_axis(ndarray)" args -> IO ()
-broadcast_axis_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_to(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-broadcast_to ::
-             forall args . Fullfilled "broadcast_to(ndarray)" args =>
-               ArgsHMap "broadcast_to(ndarray)" args -> IO [NDArrayHandle]
-broadcast_to args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_to"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_to_upd ::
-                 forall args . Fullfilled "broadcast_to(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "broadcast_to(ndarray)" args -> IO ()
-broadcast_to_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_to"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_broadcast_backward(ndarray)" = '[]
-
-_broadcast_backward ::
-                    forall args . Fullfilled "_broadcast_backward(ndarray)" args =>
-                      ArgsHMap "_broadcast_backward(ndarray)" args -> IO [NDArrayHandle]
-_broadcast_backward args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_broadcast_backward"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_broadcast_backward_upd ::
-                        forall args . Fullfilled "_broadcast_backward(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_broadcast_backward(ndarray)" args -> IO ()
-_broadcast_backward_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_broadcast_backward"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_like(ndarray)" =
-     '[ '("lhs_axes", AttrOpt (Maybe [Int])),
-        '("rhs_axes", AttrOpt (Maybe [Int])),
-        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_like ::
-               forall args . Fullfilled "broadcast_like(ndarray)" args =>
-                 ArgsHMap "broadcast_like(ndarray)" args -> IO [NDArrayHandle]
-broadcast_like args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_axes",) . showValue <$>
-                 (args !? #lhs_axes :: Maybe (Maybe [Int])),
-               ("rhs_axes",) . showValue <$>
-                 (args !? #rhs_axes :: Maybe (Maybe [Int]))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_like_upd ::
-                   forall args . Fullfilled "broadcast_like(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "broadcast_like(ndarray)" args -> IO ()
-broadcast_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_axes",) . showValue <$>
-                 (args !? #lhs_axes :: Maybe (Maybe [Int])),
-               ("rhs_axes",) . showValue <$>
-                 (args !? #rhs_axes :: Maybe (Maybe [Int]))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "norm(ndarray)" =
-     '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])),
-        '("keepdims", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-norm ::
-     forall args . Fullfilled "norm(ndarray)" args =>
-       ArgsHMap "norm(ndarray)" args -> IO [NDArrayHandle]
-norm args
-  = let scalarArgs
-          = catMaybes
-              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "norm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-norm_upd ::
-         forall args . Fullfilled "norm(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "norm(ndarray)" args -> IO ()
-norm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "norm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_norm(ndarray)" = '[]
-
-_backward_norm ::
-               forall args . Fullfilled "_backward_norm(ndarray)" args =>
-                 ArgsHMap "_backward_norm(ndarray)" args -> IO [NDArrayHandle]
-_backward_norm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_norm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_norm_upd ::
-                   forall args . Fullfilled "_backward_norm(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_norm(ndarray)" args -> IO ()
-_backward_norm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_norm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_add(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_add ::
-             forall args . Fullfilled "elemwise_add(ndarray)" args =>
-               ArgsHMap "elemwise_add(ndarray)" args -> IO [NDArrayHandle]
-elemwise_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_add_upd ::
-                 forall args . Fullfilled "elemwise_add(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_add(ndarray)" args -> IO ()
-elemwise_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_grad_add(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_grad_add ::
-          forall args . Fullfilled "_grad_add(ndarray)" args =>
-            ArgsHMap "_grad_add(ndarray)" args -> IO [NDArrayHandle]
-_grad_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_grad_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_grad_add_upd ::
-              forall args . Fullfilled "_grad_add(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_grad_add(ndarray)" args -> IO ()
-_grad_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_grad_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_add(ndarray)" = '[]
-
-_backward_add ::
-              forall args . Fullfilled "_backward_add(ndarray)" args =>
-                ArgsHMap "_backward_add(ndarray)" args -> IO [NDArrayHandle]
-_backward_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_add_upd ::
-                  forall args . Fullfilled "_backward_add(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_add(ndarray)" args -> IO ()
-_backward_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_sub(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_sub ::
-             forall args . Fullfilled "elemwise_sub(ndarray)" args =>
-               ArgsHMap "elemwise_sub(ndarray)" args -> IO [NDArrayHandle]
-elemwise_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_sub_upd ::
-                 forall args . Fullfilled "elemwise_sub(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_sub(ndarray)" args -> IO ()
-elemwise_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sub(ndarray)" = '[]
-
-_backward_sub ::
-              forall args . Fullfilled "_backward_sub(ndarray)" args =>
-                ArgsHMap "_backward_sub(ndarray)" args -> IO [NDArrayHandle]
-_backward_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sub_upd ::
-                  forall args . Fullfilled "_backward_sub(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_sub(ndarray)" args -> IO ()
-_backward_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_mul(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_mul ::
-             forall args . Fullfilled "elemwise_mul(ndarray)" args =>
-               ArgsHMap "elemwise_mul(ndarray)" args -> IO [NDArrayHandle]
-elemwise_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_mul_upd ::
-                 forall args . Fullfilled "elemwise_mul(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_mul(ndarray)" args -> IO ()
-elemwise_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mul(ndarray)" = '[]
-
-_backward_mul ::
-              forall args . Fullfilled "_backward_mul(ndarray)" args =>
-                ArgsHMap "_backward_mul(ndarray)" args -> IO [NDArrayHandle]
-_backward_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mul_upd ::
-                  forall args . Fullfilled "_backward_mul(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_mul(ndarray)" args -> IO ()
-_backward_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_div(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_div ::
-             forall args . Fullfilled "elemwise_div(ndarray)" args =>
-               ArgsHMap "elemwise_div(ndarray)" args -> IO [NDArrayHandle]
-elemwise_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_div_upd ::
-                 forall args . Fullfilled "elemwise_div(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_div(ndarray)" args -> IO ()
-elemwise_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_div(ndarray)" = '[]
-
-_backward_div ::
-              forall args . Fullfilled "_backward_div(ndarray)" args =>
-                ArgsHMap "_backward_div(ndarray)" args -> IO [NDArrayHandle]
-_backward_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_div_upd ::
-                  forall args . Fullfilled "_backward_div(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_div(ndarray)" args -> IO ()
-_backward_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_mod(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_mod ::
-     forall args . Fullfilled "_mod(ndarray)" args =>
-       ArgsHMap "_mod(ndarray)" args -> IO [NDArrayHandle]
-_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_mod_upd ::
-         forall args . Fullfilled "_mod(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_mod(ndarray)" args -> IO ()
-_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mod(ndarray)" = '[]
-
-_backward_mod ::
-              forall args . Fullfilled "_backward_mod(ndarray)" args =>
-                ArgsHMap "_backward_mod(ndarray)" args -> IO [NDArrayHandle]
-_backward_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mod_upd ::
-                  forall args . Fullfilled "_backward_mod(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_mod(ndarray)" args -> IO ()
-_backward_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_elemwise_div(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_scatter_elemwise_div ::
-                      forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args =>
-                        ArgsHMap "_scatter_elemwise_div(ndarray)" args ->
-                          IO [NDArrayHandle]
-_scatter_elemwise_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_elemwise_div_upd ::
-                          forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_scatter_elemwise_div(ndarray)" args -> IO ()
-_scatter_elemwise_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_plus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_scatter_plus_scalar ::
-                     forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args =>
-                       ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_scatter_plus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_plus_scalar_upd ::
-                         forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO ()
-_scatter_plus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_minus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_scatter_minus_scalar ::
-                      forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args =>
-                        ArgsHMap "_scatter_minus_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_scatter_minus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_minus_scalar_upd ::
-                          forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_scatter_minus_scalar(ndarray)" args -> IO ()
-_scatter_minus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Embedding(ndarray)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle)]
-
-_Embedding ::
-           forall args . Fullfilled "_Embedding(ndarray)" args =>
-             ArgsHMap "_Embedding(ndarray)" args -> IO [NDArrayHandle]
-_Embedding args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Embedding_upd ::
-               forall args . Fullfilled "_Embedding(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_Embedding(ndarray)" args -> IO ()
-_Embedding_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_SparseEmbedding(ndarray)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle)]
-
-_contrib_SparseEmbedding ::
-                         forall args .
-                           Fullfilled "_contrib_SparseEmbedding(ndarray)" args =>
-                           ArgsHMap "_contrib_SparseEmbedding(ndarray)" args ->
-                             IO [NDArrayHandle]
-_contrib_SparseEmbedding args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_SparseEmbedding_upd ::
-                             forall args .
-                               Fullfilled "_contrib_SparseEmbedding(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> IO ()
-_contrib_SparseEmbedding_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Embedding(ndarray)" = '[]
-
-_backward_Embedding ::
-                    forall args . Fullfilled "_backward_Embedding(ndarray)" args =>
-                      ArgsHMap "_backward_Embedding(ndarray)" args -> IO [NDArrayHandle]
-_backward_Embedding args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Embedding_upd ::
-                        forall args . Fullfilled "_backward_Embedding(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_Embedding(ndarray)" args -> IO ()
-_backward_Embedding_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SparseEmbedding(ndarray)" =
-     '[]
-
-_backward_SparseEmbedding ::
-                          forall args .
-                            Fullfilled "_backward_SparseEmbedding(ndarray)" args =>
-                            ArgsHMap "_backward_SparseEmbedding(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_SparseEmbedding args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SparseEmbedding_upd ::
-                              forall args .
-                                Fullfilled "_backward_SparseEmbedding(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> IO ()
-_backward_SparseEmbedding_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "take(ndarray)" =
-     '[ '("axis", AttrOpt Int),
-        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),
-        '("a", AttrOpt NDArrayHandle), '("indices", AttrOpt NDArrayHandle)]
-
-take ::
-     forall args . Fullfilled "take(ndarray)" args =>
-       ArgsHMap "take(ndarray)" args -> IO [NDArrayHandle]
-take args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-take_upd ::
-         forall args . Fullfilled "take(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "take(ndarray)" args -> IO ()
-take_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_take(ndarray)" = '[]
-
-_backward_take ::
-               forall args . Fullfilled "_backward_take(ndarray)" args =>
-                 ArgsHMap "_backward_take(ndarray)" args -> IO [NDArrayHandle]
-_backward_take args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_take_upd ::
-                   forall args . Fullfilled "_backward_take(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_take(ndarray)" args -> IO ()
-_backward_take_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "batch_take(ndarray)" =
-     '[ '("a", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-batch_take ::
-           forall args . Fullfilled "batch_take(ndarray)" args =>
-             ArgsHMap "batch_take(ndarray)" args -> IO [NDArrayHandle]
-batch_take args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-batch_take_upd ::
-               forall args . Fullfilled "batch_take(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "batch_take(ndarray)" args -> IO ()
-batch_take_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "one_hot(ndarray)" =
-     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),
-        '("off_value", AttrOpt Double),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("indices", AttrOpt NDArrayHandle)]
-
-one_hot ::
-        forall args . Fullfilled "one_hot(ndarray)" args =>
-          ArgsHMap "one_hot(ndarray)" args -> IO [NDArrayHandle]
-one_hot args
-  = let scalarArgs
-          = catMaybes
-              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),
-               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),
-               ("off_value",) . showValue <$>
-                 (args !? #off_value :: Maybe Double),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "one_hot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-one_hot_upd ::
-            forall args . Fullfilled "one_hot(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "one_hot(ndarray)" args -> IO ()
-one_hot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),
-               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),
-               ("off_value",) . showValue <$>
-                 (args !? #off_value :: Maybe Double),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "one_hot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "gather_nd(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-gather_nd ::
-          forall args . Fullfilled "gather_nd(ndarray)" args =>
-            ArgsHMap "gather_nd(ndarray)" args -> IO [NDArrayHandle]
-gather_nd args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gather_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-gather_nd_upd ::
-              forall args . Fullfilled "gather_nd(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "gather_nd(ndarray)" args -> IO ()
-gather_nd_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gather_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "scatter_nd(ndarray)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-scatter_nd ::
-           forall args . Fullfilled "scatter_nd(ndarray)" args =>
-             ArgsHMap "scatter_nd(ndarray)" args -> IO [NDArrayHandle]
-scatter_nd args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "scatter_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-scatter_nd_upd ::
-               forall args . Fullfilled "scatter_nd(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "scatter_nd(ndarray)" args -> IO ()
-scatter_nd_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "scatter_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_gather_nd(ndarray)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-_backward_gather_nd ::
-                    forall args . Fullfilled "_backward_gather_nd(ndarray)" args =>
-                      ArgsHMap "_backward_gather_nd(ndarray)" args -> IO [NDArrayHandle]
-_backward_gather_nd args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gather_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_gather_nd_upd ::
-                        forall args . Fullfilled "_backward_gather_nd(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_gather_nd(ndarray)" args -> IO ()
-_backward_gather_nd_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gather_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_set_nd(ndarray)" =
-     '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-_scatter_set_nd ::
-                forall args . Fullfilled "_scatter_set_nd(ndarray)" args =>
-                  ArgsHMap "_scatter_set_nd(ndarray)" args -> IO [NDArrayHandle]
-_scatter_set_nd args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_set_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_set_nd_upd ::
-                    forall args . Fullfilled "_scatter_set_nd(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_scatter_set_nd(ndarray)" args -> IO ()
-_scatter_set_nd_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_set_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_equal ::
-                forall args . Fullfilled "broadcast_equal(ndarray)" args =>
-                  ArgsHMap "broadcast_equal(ndarray)" args -> IO [NDArrayHandle]
-broadcast_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_equal_upd ::
-                    forall args . Fullfilled "broadcast_equal(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "broadcast_equal(ndarray)" args -> IO ()
-broadcast_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_not_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_not_equal ::
-                    forall args . Fullfilled "broadcast_not_equal(ndarray)" args =>
-                      ArgsHMap "broadcast_not_equal(ndarray)" args -> IO [NDArrayHandle]
-broadcast_not_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_not_equal_upd ::
-                        forall args . Fullfilled "broadcast_not_equal(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "broadcast_not_equal(ndarray)" args -> IO ()
-broadcast_not_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_greater(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_greater ::
-                  forall args . Fullfilled "broadcast_greater(ndarray)" args =>
-                    ArgsHMap "broadcast_greater(ndarray)" args -> IO [NDArrayHandle]
-broadcast_greater args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_greater_upd ::
-                      forall args . Fullfilled "broadcast_greater(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "broadcast_greater(ndarray)" args -> IO ()
-broadcast_greater_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_greater_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_greater_equal ::
-                        forall args . Fullfilled "broadcast_greater_equal(ndarray)" args =>
-                          ArgsHMap "broadcast_greater_equal(ndarray)" args ->
-                            IO [NDArrayHandle]
-broadcast_greater_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_greater_equal_upd ::
-                            forall args . Fullfilled "broadcast_greater_equal(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "broadcast_greater_equal(ndarray)" args -> IO ()
-broadcast_greater_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_lesser(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_lesser ::
-                 forall args . Fullfilled "broadcast_lesser(ndarray)" args =>
-                   ArgsHMap "broadcast_lesser(ndarray)" args -> IO [NDArrayHandle]
-broadcast_lesser args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_lesser_upd ::
-                     forall args . Fullfilled "broadcast_lesser(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "broadcast_lesser(ndarray)" args -> IO ()
-broadcast_lesser_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_lesser_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_lesser_equal ::
-                       forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args =>
-                         ArgsHMap "broadcast_lesser_equal(ndarray)" args ->
-                           IO [NDArrayHandle]
-broadcast_lesser_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_lesser_equal_upd ::
-                           forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "broadcast_lesser_equal(ndarray)" args -> IO ()
-broadcast_lesser_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_logical_and(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_logical_and ::
-                      forall args . Fullfilled "broadcast_logical_and(ndarray)" args =>
-                        ArgsHMap "broadcast_logical_and(ndarray)" args ->
-                          IO [NDArrayHandle]
-broadcast_logical_and args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_and"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_logical_and_upd ::
-                          forall args . Fullfilled "broadcast_logical_and(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "broadcast_logical_and(ndarray)" args -> IO ()
-broadcast_logical_and_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_and"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_logical_or(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_logical_or ::
-                     forall args . Fullfilled "broadcast_logical_or(ndarray)" args =>
-                       ArgsHMap "broadcast_logical_or(ndarray)" args -> IO [NDArrayHandle]
-broadcast_logical_or args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_or"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_logical_or_upd ::
-                         forall args . Fullfilled "broadcast_logical_or(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "broadcast_logical_or(ndarray)" args -> IO ()
-broadcast_logical_or_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_or"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_logical_xor(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_logical_xor ::
-                      forall args . Fullfilled "broadcast_logical_xor(ndarray)" args =>
-                        ArgsHMap "broadcast_logical_xor(ndarray)" args ->
-                          IO [NDArrayHandle]
-broadcast_logical_xor args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_xor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_logical_xor_upd ::
-                          forall args . Fullfilled "broadcast_logical_xor(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "broadcast_logical_xor(ndarray)" args -> IO ()
-broadcast_logical_xor_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_xor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_plus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_plus_scalar ::
-             forall args . Fullfilled "_plus_scalar(ndarray)" args =>
-               ArgsHMap "_plus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_plus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_plus_scalar_upd ::
-                 forall args . Fullfilled "_plus_scalar(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_plus_scalar(ndarray)" args -> IO ()
-_plus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_minus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_minus_scalar ::
-              forall args . Fullfilled "_minus_scalar(ndarray)" args =>
-                ArgsHMap "_minus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_minus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_minus_scalar_upd ::
-                  forall args . Fullfilled "_minus_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_minus_scalar(ndarray)" args -> IO ()
-_minus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rminus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rminus_scalar ::
-               forall args . Fullfilled "_rminus_scalar(ndarray)" args =>
-                 ArgsHMap "_rminus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rminus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rminus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rminus_scalar_upd ::
-                   forall args . Fullfilled "_rminus_scalar(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_rminus_scalar(ndarray)" args -> IO ()
-_rminus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rminus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_mul_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_mul_scalar ::
-            forall args . Fullfilled "_mul_scalar(ndarray)" args =>
-              ArgsHMap "_mul_scalar(ndarray)" args -> IO [NDArrayHandle]
-_mul_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_mul_scalar_upd ::
-                forall args . Fullfilled "_mul_scalar(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_mul_scalar(ndarray)" args -> IO ()
-_mul_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mul_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_backward_mul_scalar ::
-                     forall args . Fullfilled "_backward_mul_scalar(ndarray)" args =>
-                       ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO [NDArrayHandle]
-_backward_mul_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mul_scalar_upd ::
-                         forall args . Fullfilled "_backward_mul_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO ()
-_backward_mul_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_div_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_div_scalar ::
-            forall args . Fullfilled "_div_scalar(ndarray)" args =>
-              ArgsHMap "_div_scalar(ndarray)" args -> IO [NDArrayHandle]
-_div_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_div_scalar_upd ::
-                forall args . Fullfilled "_div_scalar(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_div_scalar(ndarray)" args -> IO ()
-_div_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_div_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_backward_div_scalar ::
-                     forall args . Fullfilled "_backward_div_scalar(ndarray)" args =>
-                       ArgsHMap "_backward_div_scalar(ndarray)" args -> IO [NDArrayHandle]
-_backward_div_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_div_scalar_upd ::
-                         forall args . Fullfilled "_backward_div_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_div_scalar(ndarray)" args -> IO ()
-_backward_div_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rdiv_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rdiv_scalar ::
-             forall args . Fullfilled "_rdiv_scalar(ndarray)" args =>
-               ArgsHMap "_rdiv_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rdiv_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rdiv_scalar_upd ::
-                 forall args . Fullfilled "_rdiv_scalar(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_rdiv_scalar(ndarray)" args -> IO ()
-_rdiv_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rdiv_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rdiv_scalar ::
-                      forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args =>
-                        ArgsHMap "_backward_rdiv_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_rdiv_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rdiv_scalar_upd ::
-                          forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> IO ()
-_backward_rdiv_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_mod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_mod_scalar ::
-            forall args . Fullfilled "_mod_scalar(ndarray)" args =>
-              ArgsHMap "_mod_scalar(ndarray)" args -> IO [NDArrayHandle]
-_mod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_mod_scalar_upd ::
-                forall args . Fullfilled "_mod_scalar(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_mod_scalar(ndarray)" args -> IO ()
-_mod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_mod_scalar ::
-                     forall args . Fullfilled "_backward_mod_scalar(ndarray)" args =>
-                       ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO [NDArrayHandle]
-_backward_mod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mod_scalar_upd ::
-                         forall args . Fullfilled "_backward_mod_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO ()
-_backward_mod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rmod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rmod_scalar ::
-             forall args . Fullfilled "_rmod_scalar(ndarray)" args =>
-               ArgsHMap "_rmod_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rmod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rmod_scalar_upd ::
-                 forall args . Fullfilled "_rmod_scalar(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_rmod_scalar(ndarray)" args -> IO ()
-_rmod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rmod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rmod_scalar ::
-                      forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args =>
-                        ArgsHMap "_backward_rmod_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_rmod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rmod_scalar_upd ::
-                          forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_rmod_scalar(ndarray)" args -> IO ()
-_backward_rmod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_ravel_multi_index(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-_ravel_multi_index ::
-                   forall args . Fullfilled "_ravel_multi_index(ndarray)" args =>
-                     ArgsHMap "_ravel_multi_index(ndarray)" args -> IO [NDArrayHandle]
-_ravel_multi_index args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ravel_multi_index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_ravel_multi_index_upd ::
-                       forall args . Fullfilled "_ravel_multi_index(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_ravel_multi_index(ndarray)" args -> IO ()
-_ravel_multi_index_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ravel_multi_index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_unravel_index(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-_unravel_index ::
-               forall args . Fullfilled "_unravel_index(ndarray)" args =>
-                 ArgsHMap "_unravel_index(ndarray)" args -> IO [NDArrayHandle]
-_unravel_index args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_unravel_index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_unravel_index_upd ::
-                   forall args . Fullfilled "_unravel_index(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_unravel_index(ndarray)" args -> IO ()
-_unravel_index_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_unravel_index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argmax(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-argmax ::
-       forall args . Fullfilled "argmax(ndarray)" args =>
-         ArgsHMap "argmax(ndarray)" args -> IO [NDArrayHandle]
-argmax args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argmax_upd ::
-           forall args . Fullfilled "argmax(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "argmax(ndarray)" args -> IO ()
-argmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argmin(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-argmin ::
-       forall args . Fullfilled "argmin(ndarray)" args =>
-         ArgsHMap "argmin(ndarray)" args -> IO [NDArrayHandle]
-argmin args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argmin_upd ::
-           forall args . Fullfilled "argmin(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "argmin(ndarray)" args -> IO ()
-argmin_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argmax_channel(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-argmax_channel ::
-               forall args . Fullfilled "argmax_channel(ndarray)" args =>
-                 ArgsHMap "argmax_channel(ndarray)" args -> IO [NDArrayHandle]
-argmax_channel args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax_channel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argmax_channel_upd ::
-                   forall args . Fullfilled "argmax_channel(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "argmax_channel(ndarray)" args -> IO ()
-argmax_channel_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax_channel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "pick(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("mode", AttrOpt (EnumType '["clip", "wrap"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("index", AttrOpt NDArrayHandle)]
-
-pick ::
-     forall args . Fullfilled "pick(ndarray)" args =>
-       ArgsHMap "pick(ndarray)" args -> IO [NDArrayHandle]
-pick args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-pick_upd ::
-         forall args . Fullfilled "pick(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "pick(ndarray)" args -> IO ()
-pick_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_pick(ndarray)" = '[]
-
-_backward_pick ::
-               forall args . Fullfilled "_backward_pick(ndarray)" args =>
-                 ArgsHMap "_backward_pick(ndarray)" args -> IO [NDArrayHandle]
-_backward_pick args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_pick_upd ::
-                   forall args . Fullfilled "_backward_pick(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_pick(ndarray)" args -> IO ()
-_backward_pick_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sparse_retain(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-_sparse_retain ::
-               forall args . Fullfilled "_sparse_retain(ndarray)" args =>
-                 ArgsHMap "_sparse_retain(ndarray)" args -> IO [NDArrayHandle]
-_sparse_retain args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sparse_retain_upd ::
-                   forall args . Fullfilled "_sparse_retain(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_sparse_retain(ndarray)" args -> IO ()
-_sparse_retain_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sparse_retain(ndarray)" =
-     '[]
-
-_backward_sparse_retain ::
-                        forall args . Fullfilled "_backward_sparse_retain(ndarray)" args =>
-                          ArgsHMap "_backward_sparse_retain(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_sparse_retain args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sparse_retain_upd ::
-                            forall args . Fullfilled "_backward_sparse_retain(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_sparse_retain(ndarray)" args -> IO ()
-_backward_sparse_retain_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_where(ndarray)" =
-     '[ '("condition", AttrOpt NDArrayHandle),
-        '("x", AttrOpt NDArrayHandle), '("y", AttrOpt NDArrayHandle)]
-
-_where ::
-       forall args . Fullfilled "_where(ndarray)" args =>
-         ArgsHMap "_where(ndarray)" args -> IO [NDArrayHandle]
-_where args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle),
-               ("x",) <$> (args !? #x :: Maybe NDArrayHandle),
-               ("y",) <$> (args !? #y :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_where_upd ::
-           forall args . Fullfilled "_where(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_where(ndarray)" args -> IO ()
-_where_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle),
-               ("x",) <$> (args !? #x :: Maybe NDArrayHandle),
-               ("y",) <$> (args !? #y :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_where(ndarray)" = '[]
-
-_backward_where ::
-                forall args . Fullfilled "_backward_where(ndarray)" args =>
-                  ArgsHMap "_backward_where(ndarray)" args -> IO [NDArrayHandle]
-_backward_where args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_where_upd ::
-                    forall args . Fullfilled "_backward_where(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_where(ndarray)" args -> IO ()
-_backward_where_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "diag(ndarray)" =
-     '[ '("k", AttrOpt Int), '("axis1", AttrOpt Int),
-        '("axis2", AttrOpt Int), '("data", AttrOpt NDArrayHandle)]
-
-diag ::
-     forall args . Fullfilled "diag(ndarray)" args =>
-       ArgsHMap "diag(ndarray)" args -> IO [NDArrayHandle]
-diag args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int),
-               ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "diag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-diag_upd ::
-         forall args . Fullfilled "diag(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "diag(ndarray)" args -> IO ()
-diag_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int),
-               ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "diag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_diag(ndarray)" = '[]
-
-_backward_diag ::
-               forall args . Fullfilled "_backward_diag(ndarray)" args =>
-                 ArgsHMap "_backward_diag(ndarray)" args -> IO [NDArrayHandle]
-_backward_diag args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_diag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_diag_upd ::
-                   forall args . Fullfilled "_backward_diag(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_diag(ndarray)" args -> IO ()
-_backward_diag_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_diag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_maximum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_maximum_scalar ::
-                forall args . Fullfilled "_maximum_scalar(ndarray)" args =>
-                  ArgsHMap "_maximum_scalar(ndarray)" args -> IO [NDArrayHandle]
-_maximum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_maximum_scalar_upd ::
-                    forall args . Fullfilled "_maximum_scalar(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_maximum_scalar(ndarray)" args -> IO ()
-_maximum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_maximum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_maximum_scalar ::
-                         forall args .
-                           Fullfilled "_backward_maximum_scalar(ndarray)" args =>
-                           ArgsHMap "_backward_maximum_scalar(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_maximum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_maximum_scalar_upd ::
-                             forall args .
-                               Fullfilled "_backward_maximum_scalar(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_maximum_scalar(ndarray)" args -> IO ()
-_backward_maximum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_minimum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_minimum_scalar ::
-                forall args . Fullfilled "_minimum_scalar(ndarray)" args =>
-                  ArgsHMap "_minimum_scalar(ndarray)" args -> IO [NDArrayHandle]
-_minimum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_minimum_scalar_upd ::
-                    forall args . Fullfilled "_minimum_scalar(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_minimum_scalar(ndarray)" args -> IO ()
-_minimum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_minimum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_minimum_scalar ::
-                         forall args .
-                           Fullfilled "_backward_minimum_scalar(ndarray)" args =>
-                           ArgsHMap "_backward_minimum_scalar(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_minimum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_minimum_scalar_upd ::
-                             forall args .
-                               Fullfilled "_backward_minimum_scalar(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_minimum_scalar(ndarray)" args -> IO ()
-_backward_minimum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_power_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_power_scalar ::
-              forall args . Fullfilled "_power_scalar(ndarray)" args =>
-                ArgsHMap "_power_scalar(ndarray)" args -> IO [NDArrayHandle]
-_power_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_power_scalar_upd ::
-                  forall args . Fullfilled "_power_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_power_scalar(ndarray)" args -> IO ()
-_power_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_power_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_power_scalar ::
-                       forall args . Fullfilled "_backward_power_scalar(ndarray)" args =>
-                         ArgsHMap "_backward_power_scalar(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_power_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_power_scalar_upd ::
-                           forall args . Fullfilled "_backward_power_scalar(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_power_scalar(ndarray)" args -> IO ()
-_backward_power_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rpower_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rpower_scalar ::
-               forall args . Fullfilled "_rpower_scalar(ndarray)" args =>
-                 ArgsHMap "_rpower_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rpower_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rpower_scalar_upd ::
-                   forall args . Fullfilled "_rpower_scalar(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_rpower_scalar(ndarray)" args -> IO ()
-_rpower_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rpower_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rpower_scalar ::
-                        forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args =>
-                          ArgsHMap "_backward_rpower_scalar(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_rpower_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rpower_scalar_upd ::
-                            forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_rpower_scalar(ndarray)" args -> IO ()
-_backward_rpower_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_hypot_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_hypot_scalar ::
-              forall args . Fullfilled "_hypot_scalar(ndarray)" args =>
-                ArgsHMap "_hypot_scalar(ndarray)" args -> IO [NDArrayHandle]
-_hypot_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_hypot_scalar_upd ::
-                  forall args . Fullfilled "_hypot_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_hypot_scalar(ndarray)" args -> IO ()
-_hypot_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_hypot_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_hypot_scalar ::
-                       forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args =>
-                         ArgsHMap "_backward_hypot_scalar(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_hypot_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_hypot_scalar_upd ::
-                           forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_hypot_scalar(ndarray)" args -> IO ()
-_backward_hypot_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "smooth_l1(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-smooth_l1 ::
-          forall args . Fullfilled "smooth_l1(ndarray)" args =>
-            ArgsHMap "smooth_l1(ndarray)" args -> IO [NDArrayHandle]
-smooth_l1 args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-smooth_l1_upd ::
-              forall args . Fullfilled "smooth_l1(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "smooth_l1(ndarray)" args -> IO ()
-smooth_l1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_smooth_l1(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_smooth_l1 ::
-                    forall args . Fullfilled "_backward_smooth_l1(ndarray)" args =>
-                      ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO [NDArrayHandle]
-_backward_smooth_l1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_smooth_l1_upd ::
-                        forall args . Fullfilled "_backward_smooth_l1(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO ()
-_backward_smooth_l1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "topk(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),
-        '("ret_typ",
-          AttrOpt (EnumType '["both", "indices", "mask", "value"])),
-        '("is_ascend", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-topk ::
-     forall args . Fullfilled "topk(ndarray)" args =>
-       ArgsHMap "topk(ndarray)" args -> IO [NDArrayHandle]
-topk args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ret_typ",) . showValue <$>
-                 (args !? #ret_typ ::
-                    Maybe (EnumType '["both", "indices", "mask", "value"])),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-topk_upd ::
-         forall args . Fullfilled "topk(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "topk(ndarray)" args -> IO ()
-topk_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ret_typ",) . showValue <$>
-                 (args !? #ret_typ ::
-                    Maybe (EnumType '["both", "indices", "mask", "value"])),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_topk(ndarray)" = '[]
-
-_backward_topk ::
-               forall args . Fullfilled "_backward_topk(ndarray)" args =>
-                 ArgsHMap "_backward_topk(ndarray)" args -> IO [NDArrayHandle]
-_backward_topk args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_topk_upd ::
-                   forall args . Fullfilled "_backward_topk(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_topk(ndarray)" args -> IO ()
-_backward_topk_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sort(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-sort ::
-     forall args . Fullfilled "sort(ndarray)" args =>
-       ArgsHMap "sort(ndarray)" args -> IO [NDArrayHandle]
-sort args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sort_upd ::
-         forall args . Fullfilled "sort(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sort(ndarray)" args -> IO ()
-sort_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argsort(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-argsort ::
-        forall args . Fullfilled "argsort(ndarray)" args =>
-          ArgsHMap "argsort(ndarray)" args -> IO [NDArrayHandle]
-argsort args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argsort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argsort_upd ::
-            forall args . Fullfilled "argsort(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "argsort(ndarray)" args -> IO ()
-argsort_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argsort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Reshape(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),
-        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Reshape ::
-         forall args . Fullfilled "_Reshape(ndarray)" args =>
-           ArgsHMap "_Reshape(ndarray)" args -> IO [NDArrayHandle]
-_Reshape args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("keep_highest",) . showValue <$>
-                 (args !? #keep_highest :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Reshape"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Reshape_upd ::
-             forall args . Fullfilled "_Reshape(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Reshape(ndarray)" args -> IO ()
-_Reshape_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("keep_highest",) . showValue <$>
-                 (args !? #keep_highest :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Reshape"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Flatten(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_Flatten ::
-         forall args . Fullfilled "_Flatten(ndarray)" args =>
-           ArgsHMap "_Flatten(ndarray)" args -> IO [NDArrayHandle]
-_Flatten args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Flatten"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Flatten_upd ::
-             forall args . Fullfilled "_Flatten(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Flatten(ndarray)" args -> IO ()
-_Flatten_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Flatten"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "transpose(ndarray)" =
-     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-transpose ::
-          forall args . Fullfilled "transpose(ndarray)" args =>
-            ArgsHMap "transpose(ndarray)" args -> IO [NDArrayHandle]
-transpose args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "transpose"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-transpose_upd ::
-              forall args . Fullfilled "transpose(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "transpose(ndarray)" args -> IO ()
-transpose_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "transpose"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "expand_dims(ndarray)" =
-     '[ '("axis", AttrReq Int), '("data", AttrOpt NDArrayHandle)]
-
-expand_dims ::
-            forall args . Fullfilled "expand_dims(ndarray)" args =>
-              ArgsHMap "expand_dims(ndarray)" args -> IO [NDArrayHandle]
-expand_dims args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expand_dims"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-expand_dims_upd ::
-                forall args . Fullfilled "expand_dims(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "expand_dims(ndarray)" args -> IO ()
-expand_dims_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expand_dims"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "slice(ndarray)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-slice ::
-      forall args . Fullfilled "slice(ndarray)" args =>
-        ArgsHMap "slice(ndarray)" args -> IO [NDArrayHandle]
-slice args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-slice_upd ::
-          forall args . Fullfilled "slice(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "slice(ndarray)" args -> IO ()
-slice_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_slice(ndarray)" = '[]
-
-_backward_slice ::
-                forall args . Fullfilled "_backward_slice(ndarray)" args =>
-                  ArgsHMap "_backward_slice(ndarray)" args -> IO [NDArrayHandle]
-_backward_slice args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_slice_upd ::
-                    forall args . Fullfilled "_backward_slice(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_slice(ndarray)" args -> IO ()
-_backward_slice_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_slice_assign(ndarray)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_slice_assign ::
-              forall args . Fullfilled "_slice_assign(ndarray)" args =>
-                ArgsHMap "_slice_assign(ndarray)" args -> IO [NDArrayHandle]
-_slice_assign args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_slice_assign_upd ::
-                  forall args . Fullfilled "_slice_assign(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_slice_assign(ndarray)" args -> IO ()
-_slice_assign_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_slice_assign_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Double), '("begin", AttrReq [Int]),
-        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_slice_assign_scalar ::
-                     forall args . Fullfilled "_slice_assign_scalar(ndarray)" args =>
-                       ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO [NDArrayHandle]
-_slice_assign_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_slice_assign_scalar_upd ::
-                         forall args . Fullfilled "_slice_assign_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO ()
-_slice_assign_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "slice_axis(ndarray)" =
-     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),
-        '("end", AttrReq (Maybe Int)), '("data", AttrOpt NDArrayHandle)]
-
-slice_axis ::
-           forall args . Fullfilled "slice_axis(ndarray)" args =>
-             ArgsHMap "slice_axis(ndarray)" args -> IO [NDArrayHandle]
-slice_axis args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),
-               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-slice_axis_upd ::
-               forall args . Fullfilled "slice_axis(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "slice_axis(ndarray)" args -> IO ()
-slice_axis_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),
-               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_slice_axis(ndarray)" = '[]
-
-_backward_slice_axis ::
-                     forall args . Fullfilled "_backward_slice_axis(ndarray)" args =>
-                       ArgsHMap "_backward_slice_axis(ndarray)" args -> IO [NDArrayHandle]
-_backward_slice_axis args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_slice_axis_upd ::
-                         forall args . Fullfilled "_backward_slice_axis(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_slice_axis(ndarray)" args -> IO ()
-_backward_slice_axis_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "slice_like(ndarray)" =
-     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle),
-        '("shape_like", AttrOpt NDArrayHandle)]
-
-slice_like ::
-           forall args . Fullfilled "slice_like(ndarray)" args =>
-             ArgsHMap "slice_like(ndarray)" args -> IO [NDArrayHandle]
-slice_like args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-slice_like_upd ::
-               forall args . Fullfilled "slice_like(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "slice_like(ndarray)" args -> IO ()
-slice_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_slice_like(ndarray)" = '[]
-
-_backward_slice_like ::
-                     forall args . Fullfilled "_backward_slice_like(ndarray)" args =>
-                       ArgsHMap "_backward_slice_like(ndarray)" args -> IO [NDArrayHandle]
-_backward_slice_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_slice_like_upd ::
-                         forall args . Fullfilled "_backward_slice_like(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_slice_like(ndarray)" args -> IO ()
-_backward_slice_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "clip(ndarray)" =
-     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-clip ::
-     forall args . Fullfilled "clip(ndarray)" args =>
-       ArgsHMap "clip(ndarray)" args -> IO [NDArrayHandle]
-clip args
-  = let scalarArgs
-          = catMaybes
-              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),
-               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-clip_upd ::
-         forall args . Fullfilled "clip(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "clip(ndarray)" args -> IO ()
-clip_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),
-               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_clip(ndarray)" = '[]
-
-_backward_clip ::
-               forall args . Fullfilled "_backward_clip(ndarray)" args =>
-                 ArgsHMap "_backward_clip(ndarray)" args -> IO [NDArrayHandle]
-_backward_clip args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_clip_upd ::
-                   forall args . Fullfilled "_backward_clip(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_clip(ndarray)" args -> IO ()
-_backward_clip_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "repeat(ndarray)" =
-     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),
-        '("data", AttrOpt NDArrayHandle)]
-
-repeat ::
-       forall args . Fullfilled "repeat(ndarray)" args =>
-         ArgsHMap "repeat(ndarray)" args -> IO [NDArrayHandle]
-repeat args
-  = let scalarArgs
-          = catMaybes
-              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-repeat_upd ::
-           forall args . Fullfilled "repeat(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "repeat(ndarray)" args -> IO ()
-repeat_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_repeat(ndarray)" = '[]
-
-_backward_repeat ::
-                 forall args . Fullfilled "_backward_repeat(ndarray)" args =>
-                   ArgsHMap "_backward_repeat(ndarray)" args -> IO [NDArrayHandle]
-_backward_repeat args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_repeat_upd ::
-                     forall args . Fullfilled "_backward_repeat(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_repeat(ndarray)" args -> IO ()
-_backward_repeat_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "tile(ndarray)" =
-     '[ '("reps", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)]
-
-tile ::
-     forall args . Fullfilled "tile(ndarray)" args =>
-       ArgsHMap "tile(ndarray)" args -> IO [NDArrayHandle]
-tile args
-  = let scalarArgs
-          = catMaybes
-              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-tile_upd ::
-         forall args . Fullfilled "tile(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "tile(ndarray)" args -> IO ()
-tile_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_tile(ndarray)" = '[]
-
-_backward_tile ::
-               forall args . Fullfilled "_backward_tile(ndarray)" args =>
-                 ArgsHMap "_backward_tile(ndarray)" args -> IO [NDArrayHandle]
-_backward_tile args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_tile_upd ::
-                   forall args . Fullfilled "_backward_tile(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_tile(ndarray)" args -> IO ()
-_backward_tile_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "reverse(ndarray)" =
-     '[ '("axis", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)]
-
-reverse ::
-        forall args . Fullfilled "reverse(ndarray)" args =>
-          ArgsHMap "reverse(ndarray)" args -> IO [NDArrayHandle]
-reverse args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-reverse_upd ::
-            forall args . Fullfilled "reverse(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "reverse(ndarray)" args -> IO ()
-reverse_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_reverse(ndarray)" = '[]
-
-_backward_reverse ::
-                  forall args . Fullfilled "_backward_reverse(ndarray)" args =>
-                    ArgsHMap "_backward_reverse(ndarray)" args -> IO [NDArrayHandle]
-_backward_reverse args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_reverse_upd ::
-                      forall args . Fullfilled "_backward_reverse(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_reverse(ndarray)" args -> IO ()
-_backward_reverse_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "stack(ndarray)" =
-     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-stack ::
-      forall args . Fullfilled "stack(ndarray)" args =>
-        ArgsHMap "stack(ndarray)" args -> IO [NDArrayHandle]
-stack args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "stack"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-stack_upd ::
-          forall args . Fullfilled "stack(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "stack(ndarray)" args -> IO ()
-stack_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "stack"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_stack(ndarray)" = '[]
-
-_backward_stack ::
-                forall args . Fullfilled "_backward_stack(ndarray)" args =>
-                  ArgsHMap "_backward_stack(ndarray)" args -> IO [NDArrayHandle]
-_backward_stack args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_stack"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_stack_upd ::
-                    forall args . Fullfilled "_backward_stack(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_stack(ndarray)" args -> IO ()
-_backward_stack_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_stack"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "squeeze(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])),
-        '("data", AttrOpt [NDArrayHandle])]
-
-squeeze ::
-        forall args . Fullfilled "squeeze(ndarray)" args =>
-          ArgsHMap "squeeze(ndarray)" args -> IO [NDArrayHandle]
-squeeze args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "squeeze"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-squeeze_upd ::
-            forall args . Fullfilled "squeeze(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "squeeze(ndarray)" args -> IO ()
-squeeze_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "squeeze"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_squeeze(ndarray)" = '[]
-
-_backward_squeeze ::
-                  forall args . Fullfilled "_backward_squeeze(ndarray)" args =>
-                    ArgsHMap "_backward_squeeze(ndarray)" args -> IO [NDArrayHandle]
-_backward_squeeze args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_squeeze"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_squeeze_upd ::
-                      forall args . Fullfilled "_backward_squeeze(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_squeeze(ndarray)" args -> IO ()
-_backward_squeeze_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_squeeze"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "depth_to_space(ndarray)" =
-     '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)]
-
-depth_to_space ::
-               forall args . Fullfilled "depth_to_space(ndarray)" args =>
-                 ArgsHMap "depth_to_space(ndarray)" args -> IO [NDArrayHandle]
-depth_to_space args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "depth_to_space"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-depth_to_space_upd ::
-                   forall args . Fullfilled "depth_to_space(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "depth_to_space(ndarray)" args -> IO ()
-depth_to_space_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "depth_to_space"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "space_to_depth(ndarray)" =
-     '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)]
-
-space_to_depth ::
-               forall args . Fullfilled "space_to_depth(ndarray)" args =>
-                 ArgsHMap "space_to_depth(ndarray)" args -> IO [NDArrayHandle]
-space_to_depth args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "space_to_depth"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-space_to_depth_upd ::
-                   forall args . Fullfilled "space_to_depth(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "space_to_depth(ndarray)" args -> IO ()
-space_to_depth_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "space_to_depth"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "dot(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),
-        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-dot ::
-    forall args . Fullfilled "dot(ndarray)" args =>
-      ArgsHMap "dot(ndarray)" args -> IO [NDArrayHandle]
-dot args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-dot_upd ::
-        forall args . Fullfilled "dot(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "dot(ndarray)" args -> IO ()
-dot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_dot(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-
-_backward_dot ::
-              forall args . Fullfilled "_backward_dot(ndarray)" args =>
-                ArgsHMap "_backward_dot(ndarray)" args -> IO [NDArrayHandle]
-_backward_dot args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_dot_upd ::
-                  forall args . Fullfilled "_backward_dot(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_dot(ndarray)" args -> IO ()
-_backward_dot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "batch_dot(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),
-        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-batch_dot ::
-          forall args . Fullfilled "batch_dot(ndarray)" args =>
-            ArgsHMap "batch_dot(ndarray)" args -> IO [NDArrayHandle]
-batch_dot args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-batch_dot_upd ::
-              forall args . Fullfilled "batch_dot(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "batch_dot(ndarray)" args -> IO ()
-batch_dot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_batch_dot(ndarray)" = '[]
-
-_backward_batch_dot ::
-                    forall args . Fullfilled "_backward_batch_dot(ndarray)" args =>
-                      ArgsHMap "_backward_batch_dot(ndarray)" args -> IO [NDArrayHandle]
-_backward_batch_dot args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_batch_dot_upd ::
-                        forall args . Fullfilled "_backward_batch_dot(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_batch_dot(ndarray)" args -> IO ()
-_backward_batch_dot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sin(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sin ::
-    forall args . Fullfilled "sin(ndarray)" args =>
-      ArgsHMap "sin(ndarray)" args -> IO [NDArrayHandle]
-sin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sin_upd ::
-        forall args . Fullfilled "sin(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "sin(ndarray)" args -> IO ()
-sin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sin(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sin ::
-              forall args . Fullfilled "_backward_sin(ndarray)" args =>
-                ArgsHMap "_backward_sin(ndarray)" args -> IO [NDArrayHandle]
-_backward_sin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sin_upd ::
-                  forall args . Fullfilled "_backward_sin(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_sin(ndarray)" args -> IO ()
-_backward_sin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cos(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-cos ::
-    forall args . Fullfilled "cos(ndarray)" args =>
-      ArgsHMap "cos(ndarray)" args -> IO [NDArrayHandle]
-cos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cos_upd ::
-        forall args . Fullfilled "cos(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "cos(ndarray)" args -> IO ()
-cos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cos(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_cos ::
-              forall args . Fullfilled "_backward_cos(ndarray)" args =>
-                ArgsHMap "_backward_cos(ndarray)" args -> IO [NDArrayHandle]
-_backward_cos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cos_upd ::
-                  forall args . Fullfilled "_backward_cos(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_cos(ndarray)" args -> IO ()
-_backward_cos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "tan(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-tan ::
-    forall args . Fullfilled "tan(ndarray)" args =>
-      ArgsHMap "tan(ndarray)" args -> IO [NDArrayHandle]
-tan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-tan_upd ::
-        forall args . Fullfilled "tan(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "tan(ndarray)" args -> IO ()
-tan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_tan(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_tan ::
-              forall args . Fullfilled "_backward_tan(ndarray)" args =>
-                ArgsHMap "_backward_tan(ndarray)" args -> IO [NDArrayHandle]
-_backward_tan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_tan_upd ::
-                  forall args . Fullfilled "_backward_tan(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_tan(ndarray)" args -> IO ()
-_backward_tan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arcsin(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arcsin ::
-       forall args . Fullfilled "arcsin(ndarray)" args =>
-         ArgsHMap "arcsin(ndarray)" args -> IO [NDArrayHandle]
-arcsin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arcsin_upd ::
-           forall args . Fullfilled "arcsin(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "arcsin(ndarray)" args -> IO ()
-arcsin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arcsin(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arcsin ::
-                 forall args . Fullfilled "_backward_arcsin(ndarray)" args =>
-                   ArgsHMap "_backward_arcsin(ndarray)" args -> IO [NDArrayHandle]
-_backward_arcsin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arcsin_upd ::
-                     forall args . Fullfilled "_backward_arcsin(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_arcsin(ndarray)" args -> IO ()
-_backward_arcsin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arccos(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arccos ::
-       forall args . Fullfilled "arccos(ndarray)" args =>
-         ArgsHMap "arccos(ndarray)" args -> IO [NDArrayHandle]
-arccos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arccos_upd ::
-           forall args . Fullfilled "arccos(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "arccos(ndarray)" args -> IO ()
-arccos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arccos(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arccos ::
-                 forall args . Fullfilled "_backward_arccos(ndarray)" args =>
-                   ArgsHMap "_backward_arccos(ndarray)" args -> IO [NDArrayHandle]
-_backward_arccos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arccos_upd ::
-                     forall args . Fullfilled "_backward_arccos(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_arccos(ndarray)" args -> IO ()
-_backward_arccos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arctan(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arctan ::
-       forall args . Fullfilled "arctan(ndarray)" args =>
-         ArgsHMap "arctan(ndarray)" args -> IO [NDArrayHandle]
-arctan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arctan_upd ::
-           forall args . Fullfilled "arctan(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "arctan(ndarray)" args -> IO ()
-arctan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arctan(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arctan ::
-                 forall args . Fullfilled "_backward_arctan(ndarray)" args =>
-                   ArgsHMap "_backward_arctan(ndarray)" args -> IO [NDArrayHandle]
-_backward_arctan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arctan_upd ::
-                     forall args . Fullfilled "_backward_arctan(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_arctan(ndarray)" args -> IO ()
-_backward_arctan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "degrees(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-degrees ::
-        forall args . Fullfilled "degrees(ndarray)" args =>
-          ArgsHMap "degrees(ndarray)" args -> IO [NDArrayHandle]
-degrees args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-degrees_upd ::
-            forall args . Fullfilled "degrees(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "degrees(ndarray)" args -> IO ()
-degrees_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_degrees(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_degrees ::
-                  forall args . Fullfilled "_backward_degrees(ndarray)" args =>
-                    ArgsHMap "_backward_degrees(ndarray)" args -> IO [NDArrayHandle]
-_backward_degrees args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_degrees_upd ::
-                      forall args . Fullfilled "_backward_degrees(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_degrees(ndarray)" args -> IO ()
-_backward_degrees_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "radians(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-radians ::
-        forall args . Fullfilled "radians(ndarray)" args =>
-          ArgsHMap "radians(ndarray)" args -> IO [NDArrayHandle]
-radians args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-radians_upd ::
-            forall args . Fullfilled "radians(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "radians(ndarray)" args -> IO ()
-radians_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_radians(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_radians ::
-                  forall args . Fullfilled "_backward_radians(ndarray)" args =>
-                    ArgsHMap "_backward_radians(ndarray)" args -> IO [NDArrayHandle]
-_backward_radians args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_radians_upd ::
-                      forall args . Fullfilled "_backward_radians(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_radians(ndarray)" args -> IO ()
-_backward_radians_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sinh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sinh ::
-     forall args . Fullfilled "sinh(ndarray)" args =>
-       ArgsHMap "sinh(ndarray)" args -> IO [NDArrayHandle]
-sinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sinh_upd ::
-         forall args . Fullfilled "sinh(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sinh(ndarray)" args -> IO ()
-sinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sinh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sinh ::
-               forall args . Fullfilled "_backward_sinh(ndarray)" args =>
-                 ArgsHMap "_backward_sinh(ndarray)" args -> IO [NDArrayHandle]
-_backward_sinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sinh_upd ::
-                   forall args . Fullfilled "_backward_sinh(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_sinh(ndarray)" args -> IO ()
-_backward_sinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cosh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-cosh ::
-     forall args . Fullfilled "cosh(ndarray)" args =>
-       ArgsHMap "cosh(ndarray)" args -> IO [NDArrayHandle]
-cosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cosh_upd ::
-         forall args . Fullfilled "cosh(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "cosh(ndarray)" args -> IO ()
-cosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cosh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_cosh ::
-               forall args . Fullfilled "_backward_cosh(ndarray)" args =>
-                 ArgsHMap "_backward_cosh(ndarray)" args -> IO [NDArrayHandle]
-_backward_cosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cosh_upd ::
-                   forall args . Fullfilled "_backward_cosh(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cosh(ndarray)" args -> IO ()
-_backward_cosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "tanh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-tanh ::
-     forall args . Fullfilled "tanh(ndarray)" args =>
-       ArgsHMap "tanh(ndarray)" args -> IO [NDArrayHandle]
-tanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-tanh_upd ::
-         forall args . Fullfilled "tanh(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "tanh(ndarray)" args -> IO ()
-tanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_tanh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_tanh ::
-               forall args . Fullfilled "_backward_tanh(ndarray)" args =>
-                 ArgsHMap "_backward_tanh(ndarray)" args -> IO [NDArrayHandle]
-_backward_tanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_tanh_upd ::
-                   forall args . Fullfilled "_backward_tanh(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_tanh(ndarray)" args -> IO ()
-_backward_tanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arcsinh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arcsinh ::
-        forall args . Fullfilled "arcsinh(ndarray)" args =>
-          ArgsHMap "arcsinh(ndarray)" args -> IO [NDArrayHandle]
-arcsinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arcsinh_upd ::
-            forall args . Fullfilled "arcsinh(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "arcsinh(ndarray)" args -> IO ()
-arcsinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arcsinh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arcsinh ::
-                  forall args . Fullfilled "_backward_arcsinh(ndarray)" args =>
-                    ArgsHMap "_backward_arcsinh(ndarray)" args -> IO [NDArrayHandle]
-_backward_arcsinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arcsinh_upd ::
-                      forall args . Fullfilled "_backward_arcsinh(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_arcsinh(ndarray)" args -> IO ()
-_backward_arcsinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arccosh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arccosh ::
-        forall args . Fullfilled "arccosh(ndarray)" args =>
-          ArgsHMap "arccosh(ndarray)" args -> IO [NDArrayHandle]
-arccosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arccosh_upd ::
-            forall args . Fullfilled "arccosh(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "arccosh(ndarray)" args -> IO ()
-arccosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arccosh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arccosh ::
-                  forall args . Fullfilled "_backward_arccosh(ndarray)" args =>
-                    ArgsHMap "_backward_arccosh(ndarray)" args -> IO [NDArrayHandle]
-_backward_arccosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arccosh_upd ::
-                      forall args . Fullfilled "_backward_arccosh(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_arccosh(ndarray)" args -> IO ()
-_backward_arccosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arctanh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arctanh ::
-        forall args . Fullfilled "arctanh(ndarray)" args =>
-          ArgsHMap "arctanh(ndarray)" args -> IO [NDArrayHandle]
-arctanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arctanh_upd ::
-            forall args . Fullfilled "arctanh(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "arctanh(ndarray)" args -> IO ()
-arctanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arctanh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arctanh ::
-                  forall args . Fullfilled "_backward_arctanh(ndarray)" args =>
-                    ArgsHMap "_backward_arctanh(ndarray)" args -> IO [NDArrayHandle]
-_backward_arctanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arctanh_upd ::
-                      forall args . Fullfilled "_backward_arctanh(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_arctanh(ndarray)" args -> IO ()
-_backward_arctanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_contrib_group_adagrad_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle),
-        '("history", AttrOpt NDArrayHandle)]
-
-_contrib_group_adagrad_update ::
-                              forall args .
-                                Fullfilled "_contrib_group_adagrad_update(ndarray)" args =>
-                                ArgsHMap "_contrib_group_adagrad_update(ndarray)" args ->
-                                  IO [NDArrayHandle]
-_contrib_group_adagrad_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_group_adagrad_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_group_adagrad_update_upd ::
-                                  forall args .
-                                    Fullfilled "_contrib_group_adagrad_update(ndarray)" args =>
-                                    [NDArrayHandle] ->
-                                      ArgsHMap "_contrib_group_adagrad_update(ndarray)" args ->
-                                        IO ()
-_contrib_group_adagrad_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_group_adagrad_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_getnnz(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_getnnz ::
-                forall args . Fullfilled "_contrib_getnnz(ndarray)" args =>
-                  ArgsHMap "_contrib_getnnz(ndarray)" args -> IO [NDArrayHandle]
-_contrib_getnnz args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_getnnz"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_getnnz_upd ::
-                    forall args . Fullfilled "_contrib_getnnz(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_contrib_getnnz(ndarray)" args -> IO ()
-_contrib_getnnz_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_getnnz"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_edge_id(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle), '("u", AttrOpt NDArrayHandle),
-        '("v", AttrOpt NDArrayHandle)]
-
-_contrib_edge_id ::
-                 forall args . Fullfilled "_contrib_edge_id(ndarray)" args =>
-                   ArgsHMap "_contrib_edge_id(ndarray)" args -> IO [NDArrayHandle]
-_contrib_edge_id args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("u",) <$> (args !? #u :: Maybe NDArrayHandle),
-               ("v",) <$> (args !? #v :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_edge_id"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_edge_id_upd ::
-                     forall args . Fullfilled "_contrib_edge_id(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_contrib_edge_id(ndarray)" args -> IO ()
-_contrib_edge_id_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("u",) <$> (args !? #u :: Maybe NDArrayHandle),
-               ("v",) <$> (args !? #v :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_edge_id"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_dgl_adjacency(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_contrib_dgl_adjacency ::
-                       forall args . Fullfilled "_contrib_dgl_adjacency(ndarray)" args =>
-                         ArgsHMap "_contrib_dgl_adjacency(ndarray)" args ->
-                           IO [NDArrayHandle]
-_contrib_dgl_adjacency args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dgl_adjacency"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_dgl_adjacency_upd ::
-                           forall args . Fullfilled "_contrib_dgl_adjacency(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_contrib_dgl_adjacency(ndarray)" args -> IO ()
-_contrib_dgl_adjacency_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dgl_adjacency"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quadratic(ndarray)" =
-     '[ '("a", AttrOpt Float), '("b", AttrOpt Float),
-        '("c", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_contrib_quadratic ::
-                   forall args . Fullfilled "_contrib_quadratic(ndarray)" args =>
-                     ArgsHMap "_contrib_quadratic(ndarray)" args -> IO [NDArrayHandle]
-_contrib_quadratic args
-  = let scalarArgs
-          = catMaybes
-              [("a",) . showValue <$> (args !? #a :: Maybe Float),
-               ("b",) . showValue <$> (args !? #b :: Maybe Float),
-               ("c",) . showValue <$> (args !? #c :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quadratic"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quadratic_upd ::
-                       forall args . Fullfilled "_contrib_quadratic(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_contrib_quadratic(ndarray)" args -> IO ()
-_contrib_quadratic_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("a",) . showValue <$> (args !? #a :: Maybe Float),
-               ("b",) . showValue <$> (args !? #b :: Maybe Float),
-               ("c",) . showValue <$> (args !? #c :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quadratic"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_backward_quadratic(ndarray)"
-     = '[]
-
-_contrib_backward_quadratic ::
-                            forall args .
-                              Fullfilled "_contrib_backward_quadratic(ndarray)" args =>
-                              ArgsHMap "_contrib_backward_quadratic(ndarray)" args ->
-                                IO [NDArrayHandle]
-_contrib_backward_quadratic args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_quadratic"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_backward_quadratic_upd ::
-                                forall args .
-                                  Fullfilled "_contrib_backward_quadratic(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_contrib_backward_quadratic(ndarray)" args -> IO ()
-_contrib_backward_quadratic_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_quadratic"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_div_sqrt_dim(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_contrib_div_sqrt_dim ::
-                      forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args =>
-                        ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args ->
-                          IO [NDArrayHandle]
-_contrib_div_sqrt_dim args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_div_sqrt_dim_upd ::
-                          forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args -> IO ()
-_contrib_div_sqrt_dim_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "khatri_rao(ndarray)" =
-     '[ '("args", AttrOpt [NDArrayHandle])]
-
-khatri_rao ::
-           forall args . Fullfilled "khatri_rao(ndarray)" args =>
-             ArgsHMap "khatri_rao(ndarray)" args -> IO [NDArrayHandle]
-khatri_rao args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "khatri_rao"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-khatri_rao_upd ::
-               forall args . Fullfilled "khatri_rao(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "khatri_rao(ndarray)" args -> IO ()
-khatri_rao_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "khatri_rao"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_index_copy(ndarray)" =
-     '[ '("old_tensor", AttrOpt NDArrayHandle),
-        '("index_vector", AttrOpt NDArrayHandle),
-        '("new_tensor", AttrOpt NDArrayHandle)]
-
-_contrib_index_copy ::
-                    forall args . Fullfilled "_contrib_index_copy(ndarray)" args =>
-                      ArgsHMap "_contrib_index_copy(ndarray)" args -> IO [NDArrayHandle]
-_contrib_index_copy args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("old_tensor",) <$> (args !? #old_tensor :: Maybe NDArrayHandle),
-               ("index_vector",) <$>
-                 (args !? #index_vector :: Maybe NDArrayHandle),
-               ("new_tensor",) <$> (args !? #new_tensor :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_index_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_index_copy_upd ::
-                        forall args . Fullfilled "_contrib_index_copy(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_contrib_index_copy(ndarray)" args -> IO ()
-_contrib_index_copy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("old_tensor",) <$> (args !? #old_tensor :: Maybe NDArrayHandle),
-               ("index_vector",) <$>
-                 (args !? #index_vector :: Maybe NDArrayHandle),
-               ("new_tensor",) <$> (args !? #new_tensor :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_index_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_backward_index_copy(ndarray)"
-     = '[]
-
-_contrib_backward_index_copy ::
-                             forall args .
-                               Fullfilled "_contrib_backward_index_copy(ndarray)" args =>
-                               ArgsHMap "_contrib_backward_index_copy(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_contrib_backward_index_copy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_index_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_backward_index_copy_upd ::
-                                 forall args .
-                                   Fullfilled "_contrib_backward_index_copy(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_contrib_backward_index_copy(ndarray)" args -> IO ()
-_contrib_backward_index_copy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_index_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_ROIAlign(ndarray)" =
-     '[ '("pooled_size", AttrReq [Int]),
-        '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)]
-
-_contrib_ROIAlign ::
-                  forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args =>
-                    ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO [NDArrayHandle]
-_contrib_ROIAlign args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("sample_ratio",) . showValue <$>
-                 (args !? #sample_ratio :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ROIAlign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_ROIAlign_upd ::
-                      forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO ()
-_contrib_ROIAlign_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("sample_ratio",) . showValue <$>
-                 (args !? #sample_ratio :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ROIAlign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_ROIAlign(ndarray)" = '[]
-
-_backward_ROIAlign ::
-                   forall args . Fullfilled "_backward_ROIAlign(ndarray)" args =>
-                     ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO [NDArrayHandle]
-_backward_ROIAlign args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIAlign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_ROIAlign_upd ::
-                       forall args . Fullfilled "_backward_ROIAlign(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO ()
-_backward_ROIAlign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIAlign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_box_nms(ndarray)" =
-     '[ '("overlap_thresh", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),
-        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),
-        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),
-        '("in_format", AttrOpt (EnumType '["center", "corner"])),
-        '("out_format", AttrOpt (EnumType '["center", "corner"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_box_nms ::
-                 forall args . Fullfilled "_contrib_box_nms(ndarray)" args =>
-                   ArgsHMap "_contrib_box_nms(ndarray)" args -> IO [NDArrayHandle]
-_contrib_box_nms args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_nms"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_box_nms_upd ::
-                     forall args . Fullfilled "_contrib_box_nms(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_contrib_box_nms(ndarray)" args -> IO ()
-_contrib_box_nms_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_nms"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_contrib_box_nms(ndarray)" =
-     '[ '("overlap_thresh", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),
-        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),
-        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),
-        '("in_format", AttrOpt (EnumType '["center", "corner"])),
-        '("out_format", AttrOpt (EnumType '["center", "corner"]))]
-
-_backward_contrib_box_nms ::
-                          forall args .
-                            Fullfilled "_backward_contrib_box_nms(ndarray)" args =>
-                            ArgsHMap "_backward_contrib_box_nms(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_contrib_box_nms args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_nms"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_box_nms_upd ::
-                              forall args .
-                                Fullfilled "_backward_contrib_box_nms(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_contrib_box_nms(ndarray)" args -> IO ()
-_backward_contrib_box_nms_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_nms"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_box_iou(ndarray)" =
-     '[ '("format", AttrOpt (EnumType '["center", "corner"])),
-        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-_contrib_box_iou ::
-                 forall args . Fullfilled "_contrib_box_iou(ndarray)" args =>
-                   ArgsHMap "_contrib_box_iou(ndarray)" args -> IO [NDArrayHandle]
-_contrib_box_iou args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_iou"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_box_iou_upd ::
-                     forall args . Fullfilled "_contrib_box_iou(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_contrib_box_iou(ndarray)" args -> IO ()
-_contrib_box_iou_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_iou"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_contrib_box_iou(ndarray)" =
-     '[ '("format", AttrOpt (EnumType '["center", "corner"]))]
-
-_backward_contrib_box_iou ::
-                          forall args .
-                            Fullfilled "_backward_contrib_box_iou(ndarray)" args =>
-                            ArgsHMap "_backward_contrib_box_iou(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_contrib_box_iou args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_iou"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_box_iou_upd ::
-                              forall args .
-                                Fullfilled "_backward_contrib_box_iou(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_contrib_box_iou(ndarray)" args -> IO ()
-_backward_contrib_box_iou_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_iou"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_bipartite_matching(ndarray)"
-     =
-     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),
-        '("topk", AttrOpt Int), '("data", AttrOpt NDArrayHandle)]
-
-_contrib_bipartite_matching ::
-                            forall args .
-                              Fullfilled "_contrib_bipartite_matching(ndarray)" args =>
-                              ArgsHMap "_contrib_bipartite_matching(ndarray)" args ->
-                                IO [NDArrayHandle]
-_contrib_bipartite_matching args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_bipartite_matching"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_bipartite_matching_upd ::
-                                forall args .
-                                  Fullfilled "_contrib_bipartite_matching(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_contrib_bipartite_matching(ndarray)" args -> IO ()
-_contrib_bipartite_matching_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_bipartite_matching"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_contrib_bipartite_matching(ndarray)" =
-     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),
-        '("topk", AttrOpt Int)]
-
-_backward_contrib_bipartite_matching ::
-                                     forall args .
-                                       Fullfilled "_backward_contrib_bipartite_matching(ndarray)"
-                                         args =>
-                                       ArgsHMap "_backward_contrib_bipartite_matching(ndarray)" args
-                                         -> IO [NDArrayHandle]
-_backward_contrib_bipartite_matching args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_bipartite_matching_upd ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward_contrib_bipartite_matching(ndarray)" args =>
-                                           [NDArrayHandle] ->
-                                             ArgsHMap
-                                               "_backward_contrib_bipartite_matching(ndarray)"
-                                               args
-                                               -> IO ()
-_backward_contrib_bipartite_matching_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_BilinearResize2D(ndarray)" =
-     '[ '("height", AttrReq Int), '("width", AttrReq Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_BilinearResize2D ::
-                          forall args .
-                            Fullfilled "_contrib_BilinearResize2D(ndarray)" args =>
-                            ArgsHMap "_contrib_BilinearResize2D(ndarray)" args ->
-                              IO [NDArrayHandle]
-_contrib_BilinearResize2D args
-  = let scalarArgs
-          = catMaybes
-              [("height",) . showValue <$> (args !? #height :: Maybe Int),
-               ("width",) . showValue <$> (args !? #width :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_BilinearResize2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_BilinearResize2D_upd ::
-                              forall args .
-                                Fullfilled "_contrib_BilinearResize2D(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_contrib_BilinearResize2D(ndarray)" args -> IO ()
-_contrib_BilinearResize2D_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("height",) . showValue <$> (args !? #height :: Maybe Int),
-               ("width",) . showValue <$> (args !? #width :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_BilinearResize2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_contrib_BilinearResize2D(ndarray)" = '[]
-
-_backward_contrib_BilinearResize2D ::
-                                   forall args .
-                                     Fullfilled "_backward_contrib_BilinearResize2D(ndarray)"
-                                       args =>
-                                     ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)" args ->
-                                       IO [NDArrayHandle]
-_backward_contrib_BilinearResize2D args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_BilinearResize2D_upd ::
-                                       forall args .
-                                         Fullfilled "_backward_contrib_BilinearResize2D(ndarray)"
-                                           args =>
-                                         [NDArrayHandle] ->
-                                           ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)"
-                                             args
-                                             -> IO ()
-_backward_contrib_BilinearResize2D_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_boolean_mask(ndarray)" =
-     '[ '("axis", AttrOpt Int), '("data", AttrOpt NDArrayHandle),
-        '("index", AttrOpt NDArrayHandle)]
-
-_contrib_boolean_mask ::
-                      forall args . Fullfilled "_contrib_boolean_mask(ndarray)" args =>
-                        ArgsHMap "_contrib_boolean_mask(ndarray)" args ->
-                          IO [NDArrayHandle]
-_contrib_boolean_mask args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_boolean_mask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_boolean_mask_upd ::
-                          forall args . Fullfilled "_contrib_boolean_mask(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_contrib_boolean_mask(ndarray)" args -> IO ()
-_contrib_boolean_mask_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_boolean_mask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_contrib_boolean_mask(ndarray)" =
-     '[ '("axis", AttrOpt Int)]
-
-_backward_contrib_boolean_mask ::
-                               forall args .
-                                 Fullfilled "_backward_contrib_boolean_mask(ndarray)" args =>
-                                 ArgsHMap "_backward_contrib_boolean_mask(ndarray)" args ->
-                                   IO [NDArrayHandle]
-_backward_contrib_boolean_mask args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_boolean_mask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_boolean_mask_upd ::
-                                   forall args .
-                                     Fullfilled "_backward_contrib_boolean_mask(ndarray)" args =>
-                                     [NDArrayHandle] ->
-                                       ArgsHMap "_backward_contrib_boolean_mask(ndarray)" args ->
-                                         IO ()
-_backward_contrib_boolean_mask_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_boolean_mask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_SyncBatchNorm(ndarray)" =
-     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int),
-        '("key", AttrOpt String), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle),
-        '("moving_mean", AttrOpt NDArrayHandle),
-        '("moving_var", AttrOpt NDArrayHandle)]
-
-_contrib_SyncBatchNorm ::
-                       forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args =>
-                         ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args ->
-                           IO [NDArrayHandle]
-_contrib_SyncBatchNorm args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),
-               ("key",) . showValue <$> (args !? #key :: Maybe String)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_SyncBatchNorm_upd ::
-                           forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args -> IO ()
-_contrib_SyncBatchNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),
-               ("key",) . showValue <$> (args !? #key :: Maybe String)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_contrib_AdaptiveAvgPooling2D(ndarray)" =
-     '[ '("output_size", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_AdaptiveAvgPooling2D ::
-                              forall args .
-                                Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args =>
-                                ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args ->
-                                  IO [NDArrayHandle]
-_contrib_AdaptiveAvgPooling2D args
-  = let scalarArgs
-          = catMaybes
-              [("output_size",) . showValue <$>
-                 (args !? #output_size :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_AdaptiveAvgPooling2D_upd ::
-                                  forall args .
-                                    Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args =>
-                                    [NDArrayHandle] ->
-                                      ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args ->
-                                        IO ()
-_contrib_AdaptiveAvgPooling2D_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("output_size",) . showValue <$>
-                 (args !? #output_size :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" =
-     '[]
-
-_backward_contrib_AdaptiveAvgPooling2D ::
-                                       forall args .
-                                         Fullfilled
-                                           "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" args =>
-                                         ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"
-                                           args
-                                           -> IO [NDArrayHandle]
-_backward_contrib_AdaptiveAvgPooling2D args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_AdaptiveAvgPooling2D_upd ::
-                                           forall args .
-                                             Fullfilled
-                                               "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"
-                                               args =>
-                                             [NDArrayHandle] ->
-                                               ArgsHMap
-                                                 "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"
-                                                 args
-                                                 -> IO ()
-_backward_contrib_AdaptiveAvgPooling2D_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_to_tensor(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_to_tensor ::
-                 forall args . Fullfilled "_image_to_tensor(ndarray)" args =>
-                   ArgsHMap "_image_to_tensor(ndarray)" args -> IO [NDArrayHandle]
-_image_to_tensor args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_to_tensor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_to_tensor_upd ::
-                     forall args . Fullfilled "_image_to_tensor(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_image_to_tensor(ndarray)" args -> IO ()
-_image_to_tensor_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_to_tensor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_normalize(ndarray)" =
-     '[ '("mean", AttrReq [Float]), '("std", AttrReq [Float]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_normalize ::
-                 forall args . Fullfilled "_image_normalize(ndarray)" args =>
-                   ArgsHMap "_image_normalize(ndarray)" args -> IO [NDArrayHandle]
-_image_normalize args
-  = let scalarArgs
-          = catMaybes
-              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),
-               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_normalize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_normalize_upd ::
-                     forall args . Fullfilled "_image_normalize(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_image_normalize(ndarray)" args -> IO ()
-_image_normalize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),
-               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_normalize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_flip_left_right(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_flip_left_right ::
-                       forall args . Fullfilled "_image_flip_left_right(ndarray)" args =>
-                         ArgsHMap "_image_flip_left_right(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_flip_left_right args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_left_right"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_flip_left_right_upd ::
-                           forall args . Fullfilled "_image_flip_left_right(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_flip_left_right(ndarray)" args -> IO ()
-_image_flip_left_right_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_left_right"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_image_random_flip_left_right(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_random_flip_left_right ::
-                              forall args .
-                                Fullfilled "_image_random_flip_left_right(ndarray)" args =>
-                                ArgsHMap "_image_random_flip_left_right(ndarray)" args ->
-                                  IO [NDArrayHandle]
-_image_random_flip_left_right args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_left_right"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_flip_left_right_upd ::
-                                  forall args .
-                                    Fullfilled "_image_random_flip_left_right(ndarray)" args =>
-                                    [NDArrayHandle] ->
-                                      ArgsHMap "_image_random_flip_left_right(ndarray)" args ->
-                                        IO ()
-_image_random_flip_left_right_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_left_right"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_flip_top_bottom(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_flip_top_bottom ::
-                       forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args =>
-                         ArgsHMap "_image_flip_top_bottom(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_flip_top_bottom args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_top_bottom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_flip_top_bottom_upd ::
-                           forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_flip_top_bottom(ndarray)" args -> IO ()
-_image_flip_top_bottom_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_top_bottom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_image_random_flip_top_bottom(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_random_flip_top_bottom ::
-                              forall args .
-                                Fullfilled "_image_random_flip_top_bottom(ndarray)" args =>
-                                ArgsHMap "_image_random_flip_top_bottom(ndarray)" args ->
-                                  IO [NDArrayHandle]
-_image_random_flip_top_bottom args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_top_bottom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_flip_top_bottom_upd ::
-                                  forall args .
-                                    Fullfilled "_image_random_flip_top_bottom(ndarray)" args =>
-                                    [NDArrayHandle] ->
-                                      ArgsHMap "_image_random_flip_top_bottom(ndarray)" args ->
-                                        IO ()
-_image_random_flip_top_bottom_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_top_bottom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_brightness(ndarray)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_brightness ::
-                         forall args .
-                           Fullfilled "_image_random_brightness(ndarray)" args =>
-                           ArgsHMap "_image_random_brightness(ndarray)" args ->
-                             IO [NDArrayHandle]
-_image_random_brightness args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_brightness"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_brightness_upd ::
-                             forall args .
-                               Fullfilled "_image_random_brightness(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_image_random_brightness(ndarray)" args -> IO ()
-_image_random_brightness_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_brightness"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_contrast(ndarray)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_contrast ::
-                       forall args . Fullfilled "_image_random_contrast(ndarray)" args =>
-                         ArgsHMap "_image_random_contrast(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_random_contrast args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_contrast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_contrast_upd ::
-                           forall args . Fullfilled "_image_random_contrast(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_random_contrast(ndarray)" args -> IO ()
-_image_random_contrast_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_contrast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_saturation(ndarray)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_saturation ::
-                         forall args .
-                           Fullfilled "_image_random_saturation(ndarray)" args =>
-                           ArgsHMap "_image_random_saturation(ndarray)" args ->
-                             IO [NDArrayHandle]
-_image_random_saturation args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_saturation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_saturation_upd ::
-                             forall args .
-                               Fullfilled "_image_random_saturation(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_image_random_saturation(ndarray)" args -> IO ()
-_image_random_saturation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_saturation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_hue(ndarray)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_hue ::
-                  forall args . Fullfilled "_image_random_hue(ndarray)" args =>
-                    ArgsHMap "_image_random_hue(ndarray)" args -> IO [NDArrayHandle]
-_image_random_hue args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_hue"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_hue_upd ::
-                      forall args . Fullfilled "_image_random_hue(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_image_random_hue(ndarray)" args -> IO ()
-_image_random_hue_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_hue"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_color_jitter(ndarray)" =
-     '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float),
-        '("saturation", AttrReq Float), '("hue", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_color_jitter ::
-                           forall args .
-                             Fullfilled "_image_random_color_jitter(ndarray)" args =>
-                             ArgsHMap "_image_random_color_jitter(ndarray)" args ->
-                               IO [NDArrayHandle]
-_image_random_color_jitter args
-  = let scalarArgs
-          = catMaybes
-              [("brightness",) . showValue <$>
-                 (args !? #brightness :: Maybe Float),
-               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
-               ("saturation",) . showValue <$>
-                 (args !? #saturation :: Maybe Float),
-               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_color_jitter"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_color_jitter_upd ::
-                               forall args .
-                                 Fullfilled "_image_random_color_jitter(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_image_random_color_jitter(ndarray)" args -> IO ()
-_image_random_color_jitter_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("brightness",) . showValue <$>
-                 (args !? #brightness :: Maybe Float),
-               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
-               ("saturation",) . showValue <$>
-                 (args !? #saturation :: Maybe Float),
-               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_color_jitter"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_adjust_lighting(ndarray)" =
-     '[ '("alpha", AttrReq [Float]), '("data", AttrOpt NDArrayHandle)]
-
-_image_adjust_lighting ::
-                       forall args . Fullfilled "_image_adjust_lighting(ndarray)" args =>
-                         ArgsHMap "_image_adjust_lighting(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_adjust_lighting args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_adjust_lighting"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_adjust_lighting_upd ::
-                           forall args . Fullfilled "_image_adjust_lighting(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_adjust_lighting(ndarray)" args -> IO ()
-_image_adjust_lighting_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_adjust_lighting"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_lighting(ndarray)" =
-     '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_image_random_lighting ::
-                       forall args . Fullfilled "_image_random_lighting(ndarray)" args =>
-                         ArgsHMap "_image_random_lighting(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_random_lighting args
-  = let scalarArgs
-          = catMaybes
-              [("alpha_std",) . showValue <$>
-                 (args !? #alpha_std :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_lighting"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_lighting_upd ::
-                           forall args . Fullfilled "_image_random_lighting(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_random_lighting(ndarray)" args -> IO ()
-_image_random_lighting_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha_std",) . showValue <$>
-                 (args !? #alpha_std :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_lighting"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "softmax(ndarray)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("data", AttrOpt NDArrayHandle)]
-
-softmax ::
-        forall args . Fullfilled "softmax(ndarray)" args =>
-          ArgsHMap "softmax(ndarray)" args -> IO [NDArrayHandle]
-softmax args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-softmax_upd ::
-            forall args . Fullfilled "softmax(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "softmax(ndarray)" args -> IO ()
-softmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_softmax(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_softmax ::
-                  forall args . Fullfilled "_backward_softmax(ndarray)" args =>
-                    ArgsHMap "_backward_softmax(ndarray)" args -> IO [NDArrayHandle]
-_backward_softmax args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_softmax_upd ::
-                      forall args . Fullfilled "_backward_softmax(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_softmax(ndarray)" args -> IO ()
-_backward_softmax_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "softmin(ndarray)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("data", AttrOpt NDArrayHandle)]
-
-softmin ::
-        forall args . Fullfilled "softmin(ndarray)" args =>
-          ArgsHMap "softmin(ndarray)" args -> IO [NDArrayHandle]
-softmin args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-softmin_upd ::
-            forall args . Fullfilled "softmin(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "softmin(ndarray)" args -> IO ()
-softmin_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_softmin(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_softmin ::
-                  forall args . Fullfilled "_backward_softmin(ndarray)" args =>
-                    ArgsHMap "_backward_softmin(ndarray)" args -> IO [NDArrayHandle]
-_backward_softmin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_softmin_upd ::
-                      forall args . Fullfilled "_backward_softmin(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_softmin(ndarray)" args -> IO ()
-_backward_softmin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log_softmax(ndarray)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("data", AttrOpt NDArrayHandle)]
-
-log_softmax ::
-            forall args . Fullfilled "log_softmax(ndarray)" args =>
-              ArgsHMap "log_softmax(ndarray)" args -> IO [NDArrayHandle]
-log_softmax args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log_softmax_upd ::
-                forall args . Fullfilled "log_softmax(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "log_softmax(ndarray)" args -> IO ()
-log_softmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log_softmax(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log_softmax ::
-                      forall args . Fullfilled "_backward_log_softmax(ndarray)" args =>
-                        ArgsHMap "_backward_log_softmax(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_log_softmax args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log_softmax_upd ::
-                          forall args . Fullfilled "_backward_log_softmax(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_log_softmax(ndarray)" args -> IO ()
-_backward_log_softmax_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Pooling(ndarray)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),
-        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
-        '("pooling_convention",
-          AttrOpt (EnumType '["full", "same", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("p_value", AttrOpt (Maybe Int)),
-        '("count_include_pad", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Pooling ::
-         forall args . Fullfilled "_Pooling(ndarray)" args =>
-           ArgsHMap "_Pooling(ndarray)" args -> IO [NDArrayHandle]
-_Pooling args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "same", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Pooling_upd ::
-             forall args . Fullfilled "_Pooling(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Pooling(ndarray)" args -> IO ()
-_Pooling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "same", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Pooling(ndarray)" = '[]
-
-_backward_Pooling ::
-                  forall args . Fullfilled "_backward_Pooling(ndarray)" args =>
-                    ArgsHMap "_backward_Pooling(ndarray)" args -> IO [NDArrayHandle]
-_backward_Pooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Pooling_upd ::
-                      forall args . Fullfilled "_backward_Pooling(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_Pooling(ndarray)" args -> IO ()
-_backward_Pooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Deconvolution(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_Deconvolution ::
-               forall args . Fullfilled "_Deconvolution(ndarray)" args =>
-                 ArgsHMap "_Deconvolution(ndarray)" args -> IO [NDArrayHandle]
-_Deconvolution args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Deconvolution_upd ::
-                   forall args . Fullfilled "_Deconvolution(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_Deconvolution(ndarray)" args -> IO ()
-_Deconvolution_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Deconvolution(ndarray)" =
-     '[]
-
-_backward_Deconvolution ::
-                        forall args . Fullfilled "_backward_Deconvolution(ndarray)" args =>
-                          ArgsHMap "_backward_Deconvolution(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_Deconvolution args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Deconvolution_upd ::
-                            forall args . Fullfilled "_backward_Deconvolution(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_Deconvolution(ndarray)" args -> IO ()
-_backward_Deconvolution_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Activation(ndarray)" =
-     '[ '("act_type",
-          AttrReq
-            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Activation ::
-            forall args . Fullfilled "_Activation(ndarray)" args =>
-              ArgsHMap "_Activation(ndarray)" args -> IO [NDArrayHandle]
-_Activation args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Activation_upd ::
-                forall args . Fullfilled "_Activation(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_Activation(ndarray)" args -> IO ()
-_Activation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Activation(ndarray)" = '[]
-
-_backward_Activation ::
-                     forall args . Fullfilled "_backward_Activation(ndarray)" args =>
-                       ArgsHMap "_backward_Activation(ndarray)" args -> IO [NDArrayHandle]
-_backward_Activation args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Activation_upd ::
-                         forall args . Fullfilled "_backward_Activation(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_Activation(ndarray)" args -> IO ()
-_backward_Activation_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_UpSampling(ndarray)" =
-     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),
-        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),
-        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),
-        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_UpSampling ::
-            forall args . Fullfilled "_UpSampling(ndarray)" args =>
-              ArgsHMap "_UpSampling(ndarray)" args -> IO [NDArrayHandle]
-_UpSampling args
-  = let scalarArgs
-          = catMaybes
-              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("sample_type",) . showValue <$>
-                 (args !? #sample_type ::
-                    Maybe (EnumType '["bilinear", "nearest"])),
-               ("multi_input_mode",) . showValue <$>
-                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "UpSampling"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_UpSampling_upd ::
-                forall args . Fullfilled "_UpSampling(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_UpSampling(ndarray)" args -> IO ()
-_UpSampling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("sample_type",) . showValue <$>
-                 (args !? #sample_type ::
-                    Maybe (EnumType '["bilinear", "nearest"])),
-               ("multi_input_mode",) . showValue <$>
-                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "UpSampling"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_UpSampling(ndarray)" = '[]
-
-_backward_UpSampling ::
-                     forall args . Fullfilled "_backward_UpSampling(ndarray)" args =>
-                       ArgsHMap "_backward_UpSampling(ndarray)" args -> IO [NDArrayHandle]
-_backward_UpSampling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_UpSampling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_UpSampling_upd ::
-                         forall args . Fullfilled "_backward_UpSampling(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_UpSampling(ndarray)" args -> IO ()
-_backward_UpSampling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_UpSampling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BatchNorm(ndarray)" =
-     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle),
-        '("moving_mean", AttrOpt NDArrayHandle),
-        '("moving_var", AttrOpt NDArrayHandle)]
-
-_BatchNorm ::
-           forall args . Fullfilled "_BatchNorm(ndarray)" args =>
-             ArgsHMap "_BatchNorm(ndarray)" args -> IO [NDArrayHandle]
-_BatchNorm args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BatchNorm_upd ::
-               forall args . Fullfilled "_BatchNorm(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_BatchNorm(ndarray)" args -> IO ()
-_BatchNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_BatchNorm(ndarray)" = '[]
-
-_backward_BatchNorm ::
-                    forall args . Fullfilled "_backward_BatchNorm(ndarray)" args =>
-                      ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO [NDArrayHandle]
-_backward_BatchNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_BatchNorm_upd ::
-                        forall args . Fullfilled "_backward_BatchNorm(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO ()
-_backward_BatchNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CTCLoss(ndarray)" =
-     '[ '("use_data_lengths", AttrOpt Bool),
-        '("use_label_lengths", AttrOpt Bool),
-        '("blank_label", AttrOpt (EnumType '["first", "last"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle),
-        '("data_lengths", AttrOpt NDArrayHandle),
-        '("label_lengths", AttrOpt NDArrayHandle)]
-
-_CTCLoss ::
-         forall args . Fullfilled "_CTCLoss(ndarray)" args =>
-           ArgsHMap "_CTCLoss(ndarray)" args -> IO [NDArrayHandle]
-_CTCLoss args
-  = let scalarArgs
-          = catMaybes
-              [("use_data_lengths",) . showValue <$>
-                 (args !? #use_data_lengths :: Maybe Bool),
-               ("use_label_lengths",) . showValue <$>
-                 (args !? #use_label_lengths :: Maybe Bool),
-               ("blank_label",) . showValue <$>
-                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("data_lengths",) <$>
-                 (args !? #data_lengths :: Maybe NDArrayHandle),
-               ("label_lengths",) <$>
-                 (args !? #label_lengths :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CTCLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CTCLoss_upd ::
-             forall args . Fullfilled "_CTCLoss(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_CTCLoss(ndarray)" args -> IO ()
-_CTCLoss_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_data_lengths",) . showValue <$>
-                 (args !? #use_data_lengths :: Maybe Bool),
-               ("use_label_lengths",) . showValue <$>
-                 (args !? #use_label_lengths :: Maybe Bool),
-               ("blank_label",) . showValue <$>
-                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("data_lengths",) <$>
-                 (args !? #data_lengths :: Maybe NDArrayHandle),
-               ("label_lengths",) <$>
-                 (args !? #label_lengths :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CTCLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_ctc_loss(ndarray)" = '[]
-
-_backward_ctc_loss ::
-                   forall args . Fullfilled "_backward_ctc_loss(ndarray)" args =>
-                     ArgsHMap "_backward_ctc_loss(ndarray)" args -> IO [NDArrayHandle]
-_backward_ctc_loss args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ctc_loss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_ctc_loss_upd ::
-                       forall args . Fullfilled "_backward_ctc_loss(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_ctc_loss(ndarray)" args -> IO ()
-_backward_ctc_loss_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ctc_loss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_FullyConnected(ndarray)" =
-     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
-        '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_FullyConnected ::
-                forall args . Fullfilled "_FullyConnected(ndarray)" args =>
-                  ArgsHMap "_FullyConnected(ndarray)" args -> IO [NDArrayHandle]
-_FullyConnected args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_FullyConnected_upd ::
-                    forall args . Fullfilled "_FullyConnected(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_FullyConnected(ndarray)" args -> IO ()
-_FullyConnected_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_FullyConnected(ndarray)" =
-     '[]
-
-_backward_FullyConnected ::
-                         forall args .
-                           Fullfilled "_backward_FullyConnected(ndarray)" args =>
-                           ArgsHMap "_backward_FullyConnected(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_FullyConnected args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_FullyConnected_upd ::
-                             forall args .
-                               Fullfilled "_backward_FullyConnected(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_FullyConnected(ndarray)" args -> IO ()
-_backward_FullyConnected_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Convolution(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_Convolution ::
-             forall args . Fullfilled "_Convolution(ndarray)" args =>
-               ArgsHMap "_Convolution(ndarray)" args -> IO [NDArrayHandle]
-_Convolution args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Convolution_upd ::
-                 forall args . Fullfilled "_Convolution(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_Convolution(ndarray)" args -> IO ()
-_Convolution_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Convolution(ndarray)" = '[]
-
-_backward_Convolution ::
-                      forall args . Fullfilled "_backward_Convolution(ndarray)" args =>
-                        ArgsHMap "_backward_Convolution(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_Convolution args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Convolution_upd ::
-                          forall args . Fullfilled "_backward_Convolution(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_Convolution(ndarray)" args -> IO ()
-_backward_Convolution_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LayerNorm(ndarray)" =
-     '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float),
-        '("output_mean_var", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_LayerNorm ::
-           forall args . Fullfilled "_LayerNorm(ndarray)" args =>
-             ArgsHMap "_LayerNorm(ndarray)" args -> IO [NDArrayHandle]
-_LayerNorm args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LayerNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LayerNorm_upd ::
-               forall args . Fullfilled "_LayerNorm(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_LayerNorm(ndarray)" args -> IO ()
-_LayerNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LayerNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_LayerNorm(ndarray)" = '[]
-
-_backward_LayerNorm ::
-                    forall args . Fullfilled "_backward_LayerNorm(ndarray)" args =>
-                      ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO [NDArrayHandle]
-_backward_LayerNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LayerNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_LayerNorm_upd ::
-                        forall args . Fullfilled "_backward_LayerNorm(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO ()
-_backward_LayerNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LayerNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Concat(ndarray)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_Concat ::
-        forall args . Fullfilled "_Concat(ndarray)" args =>
-          ArgsHMap "_Concat(ndarray)" args -> IO [NDArrayHandle]
-_Concat args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_Concat_upd ::
-            forall args . Fullfilled "_Concat(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_Concat(ndarray)" args -> IO ()
-_Concat_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Concat(ndarray)" = '[]
-
-_backward_Concat ::
-                 forall args . Fullfilled "_backward_Concat(ndarray)" args =>
-                   ArgsHMap "_backward_Concat(ndarray)" args -> IO [NDArrayHandle]
-_backward_Concat args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Concat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Concat_upd ::
-                     forall args . Fullfilled "_backward_Concat(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_Concat(ndarray)" args -> IO ()
-_backward_Concat_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Concat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rnn_param_concat(ndarray)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_rnn_param_concat ::
-                  forall args . Fullfilled "_rnn_param_concat(ndarray)" args =>
-                    ArgsHMap "_rnn_param_concat(ndarray)" args -> IO [NDArrayHandle]
-_rnn_param_concat args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_rnn_param_concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_rnn_param_concat_upd ::
-                      forall args . Fullfilled "_rnn_param_concat(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_rnn_param_concat(ndarray)" args -> IO ()
-_rnn_param_concat_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_rnn_param_concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SoftmaxActivation(ndarray)" =
-     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_SoftmaxActivation ::
-                   forall args . Fullfilled "_SoftmaxActivation(ndarray)" args =>
-                     ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO [NDArrayHandle]
-_SoftmaxActivation args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SoftmaxActivation_upd ::
-                       forall args . Fullfilled "_SoftmaxActivation(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO ()
-_SoftmaxActivation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SoftmaxActivation(ndarray)"
-     = '[]
-
-_backward_SoftmaxActivation ::
-                            forall args .
-                              Fullfilled "_backward_SoftmaxActivation(ndarray)" args =>
-                              ArgsHMap "_backward_SoftmaxActivation(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_SoftmaxActivation args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SoftmaxActivation_upd ::
-                                forall args .
-                                  Fullfilled "_backward_SoftmaxActivation(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> IO ()
-_backward_SoftmaxActivation_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LRN(ndarray)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_LRN ::
-     forall args . Fullfilled "_LRN(ndarray)" args =>
-       ArgsHMap "_LRN(ndarray)" args -> IO [NDArrayHandle]
-_LRN args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),
-               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LRN_upd ::
-         forall args . Fullfilled "_LRN(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_LRN(ndarray)" args -> IO ()
-_LRN_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),
-               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_LRN(ndarray)" = '[]
-
-_backward_LRN ::
-              forall args . Fullfilled "_backward_LRN(ndarray)" args =>
-                ArgsHMap "_backward_LRN(ndarray)" args -> IO [NDArrayHandle]
-_backward_LRN args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_LRN_upd ::
-                  forall args . Fullfilled "_backward_LRN(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_LRN(ndarray)" args -> IO ()
-_backward_LRN_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Dropout(ndarray)" =
-     '[ '("p", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["always", "training"])),
-        '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-_Dropout ::
-         forall args . Fullfilled "_Dropout(ndarray)" args =>
-           ArgsHMap "_Dropout(ndarray)" args -> IO [NDArrayHandle]
-_Dropout args
-  = let scalarArgs
-          = catMaybes
-              [("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["always", "training"])),
-               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Dropout_upd ::
-             forall args . Fullfilled "_Dropout(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Dropout(ndarray)" args -> IO ()
-_Dropout_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["always", "training"])),
-               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Dropout(ndarray)" = '[]
-
-_backward_Dropout ::
-                  forall args . Fullfilled "_backward_Dropout(ndarray)" args =>
-                    ArgsHMap "_backward_Dropout(ndarray)" args -> IO [NDArrayHandle]
-_backward_Dropout args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Dropout_upd ::
-                      forall args . Fullfilled "_backward_Dropout(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_Dropout(ndarray)" args -> IO ()
-_backward_Dropout_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_dequantize(ndarray)" =
-     '[ '("out_type", AttrOpt (EnumType '["float32"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("min_range", AttrOpt NDArrayHandle),
-        '("max_range", AttrOpt NDArrayHandle)]
-
-_contrib_dequantize ::
-                    forall args . Fullfilled "_contrib_dequantize(ndarray)" args =>
-                      ArgsHMap "_contrib_dequantize(ndarray)" args -> IO [NDArrayHandle]
-_contrib_dequantize args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["float32"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dequantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_dequantize_upd ::
-                        forall args . Fullfilled "_contrib_dequantize(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_contrib_dequantize(ndarray)" args -> IO ()
-_contrib_dequantize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["float32"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dequantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantized_flatten(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("min_data", AttrOpt NDArrayHandle),
-        '("max_data", AttrOpt NDArrayHandle)]
-
-_contrib_quantized_flatten ::
-                           forall args .
-                             Fullfilled "_contrib_quantized_flatten(ndarray)" args =>
-                             ArgsHMap "_contrib_quantized_flatten(ndarray)" args ->
-                               IO [NDArrayHandle]
-_contrib_quantized_flatten args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_flatten"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantized_flatten_upd ::
-                               forall args .
-                                 Fullfilled "_contrib_quantized_flatten(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_contrib_quantized_flatten(ndarray)" args -> IO ()
-_contrib_quantized_flatten_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_flatten"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantized_conv(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle),
-        '("min_data", AttrOpt NDArrayHandle),
-        '("max_data", AttrOpt NDArrayHandle),
-        '("min_weight", AttrOpt NDArrayHandle),
-        '("max_weight", AttrOpt NDArrayHandle),
-        '("min_bias", AttrOpt NDArrayHandle),
-        '("max_bias", AttrOpt NDArrayHandle)]
-
-_contrib_quantized_conv ::
-                        forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args =>
-                          ArgsHMap "_contrib_quantized_conv(ndarray)" args ->
-                            IO [NDArrayHandle]
-_contrib_quantized_conv args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_conv"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantized_conv_upd ::
-                            forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_contrib_quantized_conv(ndarray)" args -> IO ()
-_contrib_quantized_conv_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_conv"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_contrib_quantized_fully_connected(ndarray)" =
-     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
-        '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle),
-        '("min_data", AttrOpt NDArrayHandle),
-        '("max_data", AttrOpt NDArrayHandle),
-        '("min_weight", AttrOpt NDArrayHandle),
-        '("max_weight", AttrOpt NDArrayHandle),
-        '("min_bias", AttrOpt NDArrayHandle),
-        '("max_bias", AttrOpt NDArrayHandle)]
-
-_contrib_quantized_fully_connected ::
-                                   forall args .
-                                     Fullfilled "_contrib_quantized_fully_connected(ndarray)"
-                                       args =>
-                                     ArgsHMap "_contrib_quantized_fully_connected(ndarray)" args ->
-                                       IO [NDArrayHandle]
-_contrib_quantized_fully_connected args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantized_fully_connected_upd ::
-                                       forall args .
-                                         Fullfilled "_contrib_quantized_fully_connected(ndarray)"
-                                           args =>
-                                         [NDArrayHandle] ->
-                                           ArgsHMap "_contrib_quantized_fully_connected(ndarray)"
-                                             args
-                                             -> IO ()
-_contrib_quantized_fully_connected_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantized_pooling(ndarray)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),
-        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
-        '("pooling_convention",
-          AttrOpt (EnumType '["full", "same", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("p_value", AttrOpt (Maybe Int)),
-        '("count_include_pad", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt NDArrayHandle),
-        '("min_data", AttrOpt NDArrayHandle),
-        '("max_data", AttrOpt NDArrayHandle)]
-
-_contrib_quantized_pooling ::
-                           forall args .
-                             Fullfilled "_contrib_quantized_pooling(ndarray)" args =>
-                             ArgsHMap "_contrib_quantized_pooling(ndarray)" args ->
-                               IO [NDArrayHandle]
-_contrib_quantized_pooling args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "same", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantized_pooling_upd ::
-                               forall args .
-                                 Fullfilled "_contrib_quantized_pooling(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_contrib_quantized_pooling(ndarray)" args -> IO ()
-_contrib_quantized_pooling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "same", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantized_concat(ndarray)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_contrib_quantized_concat ::
-                          forall args .
-                            Fullfilled "_contrib_quantized_concat(ndarray)" args =>
-                            ArgsHMap "_contrib_quantized_concat(ndarray)" args ->
-                              IO [NDArrayHandle]
-_contrib_quantized_concat args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_contrib_quantized_concat_upd ::
-                              forall args .
-                                Fullfilled "_contrib_quantized_concat(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_contrib_quantized_concat(ndarray)" args -> IO ()
-_contrib_quantized_concat_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_requantize(ndarray)" =
-     '[ '("min_calib_range", AttrOpt (Maybe Float)),
-        '("max_calib_range", AttrOpt (Maybe Float)),
-        '("data", AttrOpt NDArrayHandle),
-        '("min_range", AttrOpt NDArrayHandle),
-        '("max_range", AttrOpt NDArrayHandle)]
-
-_contrib_requantize ::
-                    forall args . Fullfilled "_contrib_requantize(ndarray)" args =>
-                      ArgsHMap "_contrib_requantize(ndarray)" args -> IO [NDArrayHandle]
-_contrib_requantize args
-  = let scalarArgs
-          = catMaybes
-              [("min_calib_range",) . showValue <$>
-                 (args !? #min_calib_range :: Maybe (Maybe Float)),
-               ("max_calib_range",) . showValue <$>
-                 (args !? #max_calib_range :: Maybe (Maybe Float))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_requantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_requantize_upd ::
-                        forall args . Fullfilled "_contrib_requantize(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_contrib_requantize(ndarray)" args -> IO ()
-_contrib_requantize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("min_calib_range",) . showValue <$>
-                 (args !? #min_calib_range :: Maybe (Maybe Float)),
-               ("max_calib_range",) . showValue <$>
-                 (args !? #max_calib_range :: Maybe (Maybe Float))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_requantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantize(ndarray)" =
-     '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("min_range", AttrOpt NDArrayHandle),
-        '("max_range", AttrOpt NDArrayHandle)]
-
-_contrib_quantize ::
-                  forall args . Fullfilled "_contrib_quantize(ndarray)" args =>
-                    ArgsHMap "_contrib_quantize(ndarray)" args -> IO [NDArrayHandle]
-_contrib_quantize args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantize_upd ::
-                      forall args . Fullfilled "_contrib_quantize(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_contrib_quantize(ndarray)" args -> IO ()
-_contrib_quantize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvimdecode(ndarray)" =
-     '[ '("flag", AttrOpt Int), '("to_rgb", AttrOpt Bool),
-        '("buf", AttrOpt NDArrayHandle)]
-
-_cvimdecode ::
-            forall args . Fullfilled "_cvimdecode(ndarray)" args =>
-              ArgsHMap "_cvimdecode(ndarray)" args -> IO [NDArrayHandle]
-_cvimdecode args
-  = let scalarArgs
-          = catMaybes
-              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvimdecode_upd ::
-                forall args . Fullfilled "_cvimdecode(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_cvimdecode(ndarray)" args -> IO ()
-_cvimdecode_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvimread(ndarray)" =
-     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),
-        '("to_rgb", AttrOpt Bool)]
-
-_cvimread ::
-          forall args . Fullfilled "_cvimread(ndarray)" args =>
-            ArgsHMap "_cvimread(ndarray)" args -> IO [NDArrayHandle]
-_cvimread args
-  = let scalarArgs
-          = catMaybes
-              [("filename",) . showValue <$> (args !? #filename :: Maybe String),
-               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimread"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvimread_upd ::
-              forall args . Fullfilled "_cvimread(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_cvimread(ndarray)" args -> IO ()
-_cvimread_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("filename",) . showValue <$> (args !? #filename :: Maybe String),
-               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimread"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvimresize(ndarray)" =
-     '[ '("w", AttrReq Int), '("h", AttrReq Int),
-        '("interp", AttrOpt Int), '("src", AttrOpt NDArrayHandle)]
-
-_cvimresize ::
-            forall args . Fullfilled "_cvimresize(ndarray)" args =>
-              ArgsHMap "_cvimresize(ndarray)" args -> IO [NDArrayHandle]
-_cvimresize args
-  = let scalarArgs
-          = catMaybes
-              [("w",) . showValue <$> (args !? #w :: Maybe Int),
-               ("h",) . showValue <$> (args !? #h :: Maybe Int),
-               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimresize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvimresize_upd ::
-                forall args . Fullfilled "_cvimresize(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_cvimresize(ndarray)" args -> IO ()
-_cvimresize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("w",) . showValue <$> (args !? #w :: Maybe Int),
-               ("h",) . showValue <$> (args !? #h :: Maybe Int),
-               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimresize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvcopyMakeBorder(ndarray)" =
-     '[ '("top", AttrReq Int), '("bot", AttrReq Int),
-        '("left", AttrReq Int), '("right", AttrReq Int),
-        '("type", AttrOpt Int), '("value", AttrOpt Double),
-        '("values", AttrOpt [Double]), '("src", AttrOpt NDArrayHandle)]
-
-_cvcopyMakeBorder ::
-                  forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args =>
-                    ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO [NDArrayHandle]
-_cvcopyMakeBorder args
-  = let scalarArgs
-          = catMaybes
-              [("top",) . showValue <$> (args !? #top :: Maybe Int),
-               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),
-               ("left",) . showValue <$> (args !? #left :: Maybe Int),
-               ("right",) . showValue <$> (args !? #right :: Maybe Int),
-               ("type",) . showValue <$> (args !? #type :: Maybe Int),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double),
-               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvcopyMakeBorder"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvcopyMakeBorder_upd ::
-                      forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO ()
-_cvcopyMakeBorder_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("top",) . showValue <$> (args !? #top :: Maybe Int),
-               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),
-               ("left",) . showValue <$> (args !? #left :: Maybe Int),
-               ("right",) . showValue <$> (args !? #right :: Maybe Int),
-               ("type",) . showValue <$> (args !? #type :: Maybe Int),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double),
-               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvcopyMakeBorder"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_NoGradient(ndarray)" = '[]
-
-_NoGradient ::
-            forall args . Fullfilled "_NoGradient(ndarray)" args =>
-              ArgsHMap "_NoGradient(ndarray)" args -> IO [NDArrayHandle]
-_NoGradient args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_NoGradient"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_NoGradient_upd ::
-                forall args . Fullfilled "_NoGradient(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_NoGradient(ndarray)" args -> IO ()
-_NoGradient_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_NoGradient"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CachedOp(ndarray)" =
-     '[ '("data", AttrOpt [NDArrayHandle])]
-
-_CachedOp ::
-          forall args . Fullfilled "_CachedOp(ndarray)" args =>
-            ArgsHMap "_CachedOp(ndarray)" args -> IO [NDArrayHandle]
-_CachedOp args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CachedOp_upd ::
-              forall args . Fullfilled "_CachedOp(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_CachedOp(ndarray)" args -> IO ()
-_CachedOp_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_CachedOp(ndarray)" = '[]
-
-_backward_CachedOp ::
-                   forall args . Fullfilled "_backward_CachedOp(ndarray)" args =>
-                     ArgsHMap "_backward_CachedOp(ndarray)" args -> IO [NDArrayHandle]
-_backward_CachedOp args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_CachedOp_upd ::
-                       forall args . Fullfilled "_backward_CachedOp(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_CachedOp(ndarray)" args -> IO ()
-_backward_CachedOp_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_copyto(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_copyto ::
-        forall args . Fullfilled "_copyto(ndarray)" args =>
-          ArgsHMap "_copyto(ndarray)" args -> IO [NDArrayHandle]
-_copyto args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copyto"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_copyto_upd ::
-            forall args . Fullfilled "_copyto(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_copyto(ndarray)" args -> IO ()
-_copyto_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copyto"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "softmax_cross_entropy(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-softmax_cross_entropy ::
-                      forall args . Fullfilled "softmax_cross_entropy(ndarray)" args =>
-                        ArgsHMap "softmax_cross_entropy(ndarray)" args ->
-                          IO [NDArrayHandle]
-softmax_cross_entropy args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-softmax_cross_entropy_upd ::
-                          forall args . Fullfilled "softmax_cross_entropy(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "softmax_cross_entropy(ndarray)" args -> IO ()
-softmax_cross_entropy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_softmax_cross_entropy(ndarray)" = '[]
-
-_backward_softmax_cross_entropy ::
-                                forall args .
-                                  Fullfilled "_backward_softmax_cross_entropy(ndarray)" args =>
-                                  ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args ->
-                                    IO [NDArrayHandle]
-_backward_softmax_cross_entropy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_softmax_cross_entropy_upd ::
-                                    forall args .
-                                      Fullfilled "_backward_softmax_cross_entropy(ndarray)" args =>
-                                      [NDArrayHandle] ->
-                                        ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args ->
-                                          IO ()
-_backward_softmax_cross_entropy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Pad(ndarray)" =
-     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),
-        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Pad ::
-     forall args . Fullfilled "_Pad(ndarray)" args =>
-       ArgsHMap "_Pad(ndarray)" args -> IO [NDArrayHandle]
-_Pad args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["constant", "edge", "reflect"])),
-               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),
-               ("constant_value",) . showValue <$>
-                 (args !? #constant_value :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Pad_upd ::
-         forall args . Fullfilled "_Pad(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_Pad(ndarray)" args -> IO ()
-_Pad_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["constant", "edge", "reflect"])),
-               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),
-               ("constant_value",) . showValue <$>
-                 (args !? #constant_value :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_foreach(ndarray)" = '[]
-
-_backward_foreach ::
-                  forall args . Fullfilled "_backward_foreach(ndarray)" args =>
-                    ArgsHMap "_backward_foreach(ndarray)" args -> IO [NDArrayHandle]
-_backward_foreach args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_foreach"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_foreach_upd ::
-                      forall args . Fullfilled "_backward_foreach(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_foreach(ndarray)" args -> IO ()
-_backward_foreach_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_foreach"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_while_loop(ndarray)" = '[]
-
-_backward_while_loop ::
-                     forall args . Fullfilled "_backward_while_loop(ndarray)" args =>
-                       ArgsHMap "_backward_while_loop(ndarray)" args -> IO [NDArrayHandle]
-_backward_while_loop args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_while_loop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_while_loop_upd ::
-                         forall args . Fullfilled "_backward_while_loop(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_while_loop(ndarray)" args -> IO ()
-_backward_while_loop_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_while_loop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cond(ndarray)" = '[]
-
-_backward_cond ::
-               forall args . Fullfilled "_backward_cond(ndarray)" args =>
-                 ArgsHMap "_backward_cond(ndarray)" args -> IO [NDArrayHandle]
-_backward_cond args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cond"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cond_upd ::
-                   forall args . Fullfilled "_backward_cond(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cond(ndarray)" args -> IO ()
-_backward_cond_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cond"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LeakyReLU(ndarray)" =
-     '[ '("act_type",
-          AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),
-        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),
-        '("upper_bound", AttrOpt Float), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle)]
-
-_LeakyReLU ::
-           forall args . Fullfilled "_LeakyReLU(ndarray)" args =>
-             ArgsHMap "_LeakyReLU(ndarray)" args -> IO [NDArrayHandle]
-_LeakyReLU args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),
-               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),
-               ("lower_bound",) . showValue <$>
-                 (args !? #lower_bound :: Maybe Float),
-               ("upper_bound",) . showValue <$>
-                 (args !? #upper_bound :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LeakyReLU_upd ::
-               forall args . Fullfilled "_LeakyReLU(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_LeakyReLU(ndarray)" args -> IO ()
-_LeakyReLU_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),
-               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),
-               ("lower_bound",) . showValue <$>
-                 (args !? #lower_bound :: Maybe Float),
-               ("upper_bound",) . showValue <$>
-                 (args !? #upper_bound :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SwapAxis(ndarray)" =
-     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_SwapAxis ::
-          forall args . Fullfilled "_SwapAxis(ndarray)" args =>
-            ArgsHMap "_SwapAxis(ndarray)" args -> IO [NDArrayHandle]
-_SwapAxis args
-  = let scalarArgs
-          = catMaybes
-              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),
-               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SwapAxis_upd ::
-              forall args . Fullfilled "_SwapAxis(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_SwapAxis(ndarray)" args -> IO ()
-_SwapAxis_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),
-               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_IdentityAttachKLSparseReg(ndarray)" =
-     '[ '("sparseness_target", AttrOpt Float),
-        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_IdentityAttachKLSparseReg ::
-                           forall args .
-                             Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args =>
-                             ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args ->
-                               IO [NDArrayHandle]
-_IdentityAttachKLSparseReg args
-  = let scalarArgs
-          = catMaybes
-              [("sparseness_target",) . showValue <$>
-                 (args !? #sparseness_target :: Maybe Float),
-               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_IdentityAttachKLSparseReg_upd ::
-                               forall args .
-                                 Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> IO ()
-_IdentityAttachKLSparseReg_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("sparseness_target",) . showValue <$>
-                 (args !? #sparseness_target :: Maybe Float),
-               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SliceChannel(ndarray)" =
-     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),
-        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-_SliceChannel ::
-              forall args . Fullfilled "_SliceChannel(ndarray)" args =>
-                ArgsHMap "_SliceChannel(ndarray)" args -> IO [NDArrayHandle]
-_SliceChannel args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SliceChannel_upd ::
-                  forall args . Fullfilled "_SliceChannel(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_SliceChannel(ndarray)" args -> IO ()
-_SliceChannel_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BatchNorm_v1(ndarray)" =
-     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_BatchNorm_v1 ::
-              forall args . Fullfilled "_BatchNorm_v1(ndarray)" args =>
-                ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO [NDArrayHandle]
-_BatchNorm_v1 args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BatchNorm_v1_upd ::
-                  forall args . Fullfilled "_BatchNorm_v1(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO ()
-_BatchNorm_v1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "signsgd_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle)]
-
-signsgd_update ::
-               forall args . Fullfilled "signsgd_update(ndarray)" args =>
-                 ArgsHMap "signsgd_update(ndarray)" args -> IO [NDArrayHandle]
-signsgd_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signsgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-signsgd_update_upd ::
-                   forall args . Fullfilled "signsgd_update(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "signsgd_update(ndarray)" args -> IO ()
-signsgd_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signsgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "signum_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]
-
-signum_update ::
-              forall args . Fullfilled "signum_update(ndarray)" args =>
-                ArgsHMap "signum_update(ndarray)" args -> IO [NDArrayHandle]
-signum_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signum_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-signum_update_upd ::
-                  forall args . Fullfilled "signum_update(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "signum_update(ndarray)" args -> IO ()
-signum_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signum_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sgd_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle)]
-
-sgd_update ::
-           forall args . Fullfilled "sgd_update(ndarray)" args =>
-             ArgsHMap "sgd_update(ndarray)" args -> IO [NDArrayHandle]
-sgd_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sgd_update_upd ::
-               forall args . Fullfilled "sgd_update(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "sgd_update(ndarray)" args -> IO ()
-sgd_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sgd_mom_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]
-
-sgd_mom_update ::
-               forall args . Fullfilled "sgd_mom_update(ndarray)" args =>
-                 ArgsHMap "sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]
-sgd_mom_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sgd_mom_update_upd ::
-                   forall args . Fullfilled "sgd_mom_update(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "sgd_mom_update(ndarray)" args -> IO ()
-sgd_mom_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "mp_sgd_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle),
-        '("weight32", AttrOpt NDArrayHandle)]
-
-mp_sgd_update ::
-              forall args . Fullfilled "mp_sgd_update(ndarray)" args =>
-                ArgsHMap "mp_sgd_update(ndarray)" args -> IO [NDArrayHandle]
-mp_sgd_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-mp_sgd_update_upd ::
-                  forall args . Fullfilled "mp_sgd_update(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "mp_sgd_update(ndarray)" args -> IO ()
-mp_sgd_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "mp_sgd_mom_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle),
-        '("weight32", AttrOpt NDArrayHandle)]
-
-mp_sgd_mom_update ::
-                  forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args =>
-                    ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]
-mp_sgd_mom_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-mp_sgd_mom_update_upd ::
-                      forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO ()
-mp_sgd_mom_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ftml_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double),
-        '("t", AttrReq Int), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("d", AttrOpt NDArrayHandle),
-        '("v", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle)]
-
-ftml_update ::
-            forall args . Fullfilled "ftml_update(ndarray)" args =>
-              ArgsHMap "ftml_update(ndarray)" args -> IO [NDArrayHandle]
-ftml_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),
-               ("t",) . showValue <$> (args !? #t :: Maybe Int),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("d",) <$> (args !? #d :: Maybe NDArrayHandle),
-               ("v",) <$> (args !? #v :: Maybe NDArrayHandle),
-               ("z",) <$> (args !? #z :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftml_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ftml_update_upd ::
-                forall args . Fullfilled "ftml_update(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "ftml_update(ndarray)" args -> IO ()
-ftml_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),
-               ("t",) . showValue <$> (args !? #t :: Maybe Int),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("d",) <$> (args !? #d :: Maybe NDArrayHandle),
-               ("v",) <$> (args !? #v :: Maybe NDArrayHandle),
-               ("z",) <$> (args !? #z :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftml_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "adam_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle),
-        '("var", AttrOpt NDArrayHandle)]
-
-adam_update ::
-            forall args . Fullfilled "adam_update(ndarray)" args =>
-              ArgsHMap "adam_update(ndarray)" args -> IO [NDArrayHandle]
-adam_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),
-               ("var",) <$> (args !? #var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "adam_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-adam_update_upd ::
-                forall args . Fullfilled "adam_update(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "adam_update(ndarray)" args -> IO ()
-adam_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),
-               ("var",) <$> (args !? #var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "adam_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rmsprop_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle)]
-
-rmsprop_update ::
-               forall args . Fullfilled "rmsprop_update(ndarray)" args =>
-                 ArgsHMap "rmsprop_update(ndarray)" args -> IO [NDArrayHandle]
-rmsprop_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmsprop_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rmsprop_update_upd ::
-                   forall args . Fullfilled "rmsprop_update(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "rmsprop_update(ndarray)" args -> IO ()
-rmsprop_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmsprop_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rmspropalex_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle),
-        '("g", AttrOpt NDArrayHandle), '("delta", AttrOpt NDArrayHandle)]
-
-rmspropalex_update ::
-                   forall args . Fullfilled "rmspropalex_update(ndarray)" args =>
-                     ArgsHMap "rmspropalex_update(ndarray)" args -> IO [NDArrayHandle]
-rmspropalex_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle),
-               ("g",) <$> (args !? #g :: Maybe NDArrayHandle),
-               ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmspropalex_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rmspropalex_update_upd ::
-                       forall args . Fullfilled "rmspropalex_update(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "rmspropalex_update(ndarray)" args -> IO ()
-rmspropalex_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle),
-               ("g",) <$> (args !? #g :: Maybe NDArrayHandle),
-               ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmspropalex_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ftrl_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),
-        '("beta", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle),
-        '("n", AttrOpt NDArrayHandle)]
-
-ftrl_update ::
-            forall args . Fullfilled "ftrl_update(ndarray)" args =>
-              ArgsHMap "ftrl_update(ndarray)" args -> IO [NDArrayHandle]
-ftrl_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("z",) <$> (args !? #z :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftrl_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ftrl_update_upd ::
-                forall args . Fullfilled "ftrl_update(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "ftrl_update(ndarray)" args -> IO ()
-ftrl_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("z",) <$> (args !? #z :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftrl_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sparse_adagrad_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle),
-        '("history", AttrOpt NDArrayHandle)]
-
-_sparse_adagrad_update ::
-                       forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args =>
-                         ArgsHMap "_sparse_adagrad_update(ndarray)" args ->
-                           IO [NDArrayHandle]
-_sparse_adagrad_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_adagrad_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sparse_adagrad_update_upd ::
-                           forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_sparse_adagrad_update(ndarray)" args -> IO ()
-_sparse_adagrad_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_adagrad_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LinearRegressionOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_LinearRegressionOutput ::
-                        forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args =>
-                          ArgsHMap "_LinearRegressionOutput(ndarray)" args ->
-                            IO [NDArrayHandle]
-_LinearRegressionOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LinearRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LinearRegressionOutput_upd ::
-                            forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_LinearRegressionOutput(ndarray)" args -> IO ()
-_LinearRegressionOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LinearRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linear_reg_out(ndarray)" =
-     '[]
-
-_backward_linear_reg_out ::
-                         forall args .
-                           Fullfilled "_backward_linear_reg_out(ndarray)" args =>
-                           ArgsHMap "_backward_linear_reg_out(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_linear_reg_out args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linear_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linear_reg_out_upd ::
-                             forall args .
-                               Fullfilled "_backward_linear_reg_out(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_linear_reg_out(ndarray)" args -> IO ()
-_backward_linear_reg_out_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linear_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_MAERegressionOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_MAERegressionOutput ::
-                     forall args . Fullfilled "_MAERegressionOutput(ndarray)" args =>
-                       ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO [NDArrayHandle]
-_MAERegressionOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MAERegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_MAERegressionOutput_upd ::
-                         forall args . Fullfilled "_MAERegressionOutput(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO ()
-_MAERegressionOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MAERegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mae_reg_out(ndarray)" = '[]
-
-_backward_mae_reg_out ::
-                      forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args =>
-                        ArgsHMap "_backward_mae_reg_out(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_mae_reg_out args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mae_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mae_reg_out_upd ::
-                          forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_mae_reg_out(ndarray)" args -> IO ()
-_backward_mae_reg_out_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mae_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LogisticRegressionOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_LogisticRegressionOutput ::
-                          forall args .
-                            Fullfilled "_LogisticRegressionOutput(ndarray)" args =>
-                            ArgsHMap "_LogisticRegressionOutput(ndarray)" args ->
-                              IO [NDArrayHandle]
-_LogisticRegressionOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LogisticRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LogisticRegressionOutput_upd ::
-                              forall args .
-                                Fullfilled "_LogisticRegressionOutput(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> IO ()
-_LogisticRegressionOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LogisticRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_logistic_reg_out(ndarray)" =
-     '[]
-
-_backward_logistic_reg_out ::
-                           forall args .
-                             Fullfilled "_backward_logistic_reg_out(ndarray)" args =>
-                             ArgsHMap "_backward_logistic_reg_out(ndarray)" args ->
-                               IO [NDArrayHandle]
-_backward_logistic_reg_out args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_logistic_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_logistic_reg_out_upd ::
-                               forall args .
-                                 Fullfilled "_backward_logistic_reg_out(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_backward_logistic_reg_out(ndarray)" args -> IO ()
-_backward_logistic_reg_out_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_logistic_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CustomFunction(ndarray)" = '[]
-
-_CustomFunction ::
-                forall args . Fullfilled "_CustomFunction(ndarray)" args =>
-                  ArgsHMap "_CustomFunction(ndarray)" args -> IO [NDArrayHandle]
-_CustomFunction args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CustomFunction_upd ::
-                    forall args . Fullfilled "_CustomFunction(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_CustomFunction(ndarray)" args -> IO ()
-_CustomFunction_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_CustomFunction(ndarray)" =
-     '[]
-
-_backward_CustomFunction ::
-                         forall args .
-                           Fullfilled "_backward_CustomFunction(ndarray)" args =>
-                           ArgsHMap "_backward_CustomFunction(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_CustomFunction args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_CustomFunction_upd ::
-                             forall args .
-                               Fullfilled "_backward_CustomFunction(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_CustomFunction(ndarray)" args -> IO ()
-_backward_CustomFunction_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__Native(ndarray)" = '[]
-
-_backward__Native ::
-                  forall args . Fullfilled "_backward__Native(ndarray)" args =>
-                    ArgsHMap "_backward__Native(ndarray)" args -> IO [NDArrayHandle]
-_backward__Native args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__Native"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__Native_upd ::
-                      forall args . Fullfilled "_backward__Native(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward__Native(ndarray)" args -> IO ()
-_backward__Native_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__Native"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__NDArray(ndarray)" = '[]
-
-_backward__NDArray ::
-                   forall args . Fullfilled "_backward__NDArray(ndarray)" args =>
-                     ArgsHMap "_backward__NDArray(ndarray)" args -> IO [NDArrayHandle]
-_backward__NDArray args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__NDArray"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__NDArray_upd ::
-                       forall args . Fullfilled "_backward__NDArray(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward__NDArray(ndarray)" args -> IO ()
-_backward__NDArray_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__NDArray"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiBoxTarget(ndarray)" =
-     '[ '("overlap_threshold", AttrOpt Float),
-        '("ignore_label", AttrOpt Float),
-        '("negative_mining_ratio", AttrOpt Float),
-        '("negative_mining_thresh", AttrOpt Float),
-        '("minimum_negative_samples", AttrOpt Int),
-        '("variances", AttrOpt [Float]),
-        '("anchor", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle),
-        '("cls_pred", AttrOpt NDArrayHandle)]
-
-_contrib_MultiBoxTarget ::
-                        forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args =>
-                          ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args ->
-                            IO [NDArrayHandle]
-_contrib_MultiBoxTarget args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_threshold",) . showValue <$>
-                 (args !? #overlap_threshold :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("negative_mining_ratio",) . showValue <$>
-                 (args !? #negative_mining_ratio :: Maybe Float),
-               ("negative_mining_thresh",) . showValue <$>
-                 (args !? #negative_mining_thresh :: Maybe Float),
-               ("minimum_negative_samples",) . showValue <$>
-                 (args !? #minimum_negative_samples :: Maybe Int),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float])]
-        tensorArgs
-          = catMaybes
-              [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiBoxTarget_upd ::
-                            forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> IO ()
-_contrib_MultiBoxTarget_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_threshold",) . showValue <$>
-                 (args !? #overlap_threshold :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("negative_mining_ratio",) . showValue <$>
-                 (args !? #negative_mining_ratio :: Maybe Float),
-               ("negative_mining_thresh",) . showValue <$>
-                 (args !? #negative_mining_thresh :: Maybe Float),
-               ("minimum_negative_samples",) . showValue <$>
-                 (args !? #minimum_negative_samples :: Maybe Int),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float])]
-        tensorArgs
-          = catMaybes
-              [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxTarget(ndarray)" = '[]
-
-_backward__contrib_MultiBoxTarget ::
-                                  forall args .
-                                    Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" args =>
-                                    ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args ->
-                                      IO [NDArrayHandle]
-_backward__contrib_MultiBoxTarget args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiBoxTarget_upd ::
-                                      forall args .
-                                        Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)"
-                                          args =>
-                                        [NDArrayHandle] ->
-                                          ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args
-                                            -> IO ()
-_backward__contrib_MultiBoxTarget_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_Proposal(ndarray)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle),
-        '("bbox_pred", AttrOpt NDArrayHandle),
-        '("im_info", AttrOpt NDArrayHandle)]
-
-_contrib_Proposal ::
-                  forall args . Fullfilled "_contrib_Proposal(ndarray)" args =>
-                    ArgsHMap "_contrib_Proposal(ndarray)" args -> IO [NDArrayHandle]
-_contrib_Proposal args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_Proposal_upd ::
-                      forall args . Fullfilled "_contrib_Proposal(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_contrib_Proposal(ndarray)" args -> IO ()
-_contrib_Proposal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__contrib_Proposal(ndarray)"
-     = '[]
-
-_backward__contrib_Proposal ::
-                            forall args .
-                              Fullfilled "_backward__contrib_Proposal(ndarray)" args =>
-                              ArgsHMap "_backward__contrib_Proposal(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward__contrib_Proposal args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_Proposal_upd ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_Proposal(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> IO ()
-_backward__contrib_Proposal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_count_sketch(ndarray)" =
-     '[ '("out_dim", AttrReq Int),
-        '("processing_batch_size", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle), '("h", AttrOpt NDArrayHandle),
-        '("s", AttrOpt NDArrayHandle)]
-
-_contrib_count_sketch ::
-                      forall args . Fullfilled "_contrib_count_sketch(ndarray)" args =>
-                        ArgsHMap "_contrib_count_sketch(ndarray)" args ->
-                          IO [NDArrayHandle]
-_contrib_count_sketch args
-  = let scalarArgs
-          = catMaybes
-              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),
-               ("processing_batch_size",) . showValue <$>
-                 (args !? #processing_batch_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("h",) <$> (args !? #h :: Maybe NDArrayHandle),
-               ("s",) <$> (args !? #s :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_count_sketch_upd ::
-                          forall args . Fullfilled "_contrib_count_sketch(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_contrib_count_sketch(ndarray)" args -> IO ()
-_contrib_count_sketch_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),
-               ("processing_batch_size",) . showValue <$>
-                 (args !? #processing_batch_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("h",) <$> (args !? #h :: Maybe NDArrayHandle),
-               ("s",) <$> (args !? #s :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_count_sketch(ndarray)" = '[]
-
-_backward__contrib_count_sketch ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_count_sketch(ndarray)" args =>
-                                  ArgsHMap "_backward__contrib_count_sketch(ndarray)" args ->
-                                    IO [NDArrayHandle]
-_backward__contrib_count_sketch args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_count_sketch_upd ::
-                                    forall args .
-                                      Fullfilled "_backward__contrib_count_sketch(ndarray)" args =>
-                                      [NDArrayHandle] ->
-                                        ArgsHMap "_backward__contrib_count_sketch(ndarray)" args ->
-                                          IO ()
-_backward__contrib_count_sketch_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiBoxDetection(ndarray)" =
-     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),
-        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),
-        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),
-        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt NDArrayHandle),
-        '("loc_pred", AttrOpt NDArrayHandle),
-        '("anchor", AttrOpt NDArrayHandle)]
-
-_contrib_MultiBoxDetection ::
-                           forall args .
-                             Fullfilled "_contrib_MultiBoxDetection(ndarray)" args =>
-                             ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args ->
-                               IO [NDArrayHandle]
-_contrib_MultiBoxDetection args
-  = let scalarArgs
-          = catMaybes
-              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("nms_threshold",) . showValue <$>
-                 (args !? #nms_threshold :: Maybe Float),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float]),
-               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle),
-               ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiBoxDetection_upd ::
-                               forall args .
-                                 Fullfilled "_contrib_MultiBoxDetection(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> IO ()
-_contrib_MultiBoxDetection_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("nms_threshold",) . showValue <$>
-                 (args !? #nms_threshold :: Maybe Float),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float]),
-               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle),
-               ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxDetection(ndarray)" = '[]
-
-_backward__contrib_MultiBoxDetection ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiBoxDetection(ndarray)"
-                                         args =>
-                                       ArgsHMap "_backward__contrib_MultiBoxDetection(ndarray)" args
-                                         -> IO [NDArrayHandle]
-_backward__contrib_MultiBoxDetection args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiBoxDetection_upd ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward__contrib_MultiBoxDetection(ndarray)" args =>
-                                           [NDArrayHandle] ->
-                                             ArgsHMap
-                                               "_backward__contrib_MultiBoxDetection(ndarray)"
-                                               args
-                                               -> IO ()
-_backward__contrib_MultiBoxDetection_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_DeformablePSROIPooling(ndarray)"
-     = '[]
-
-_backward__contrib_DeformablePSROIPooling ::
-                                          forall args .
-                                            Fullfilled
-                                              "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                              args =>
-                                            ArgsHMap
-                                              "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                              args
-                                              -> IO [NDArrayHandle]
-_backward__contrib_DeformablePSROIPooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_DeformablePSROIPooling_upd ::
-                                              forall args .
-                                                Fullfilled
-                                                  "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                                  args =>
-                                                [NDArrayHandle] ->
-                                                  ArgsHMap
-                                                    "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                                    args
-                                                    -> IO ()
-_backward__contrib_DeformablePSROIPooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_fft(ndarray)" =
-     '[ '("compute_size", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_fft ::
-             forall args . Fullfilled "_contrib_fft(ndarray)" args =>
-               ArgsHMap "_contrib_fft(ndarray)" args -> IO [NDArrayHandle]
-_contrib_fft args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_fft_upd ::
-                 forall args . Fullfilled "_contrib_fft(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_contrib_fft(ndarray)" args -> IO ()
-_contrib_fft_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__contrib_fft(ndarray)" = '[]
-
-_backward__contrib_fft ::
-                       forall args . Fullfilled "_backward__contrib_fft(ndarray)" args =>
-                         ArgsHMap "_backward__contrib_fft(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward__contrib_fft args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_fft_upd ::
-                           forall args . Fullfilled "_backward__contrib_fft(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward__contrib_fft(ndarray)" args -> IO ()
-_backward__contrib_fft_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiBoxPrior(ndarray)" =
-     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),
-        '("offsets", AttrOpt [Float]), '("data", AttrOpt NDArrayHandle)]
-
-_contrib_MultiBoxPrior ::
-                       forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args =>
-                         ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args ->
-                           IO [NDArrayHandle]
-_contrib_MultiBoxPrior args
-  = let scalarArgs
-          = catMaybes
-              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),
-               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiBoxPrior_upd ::
-                           forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> IO ()
-_contrib_MultiBoxPrior_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),
-               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxPrior(ndarray)" = '[]
-
-_backward__contrib_MultiBoxPrior ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" args =>
-                                   ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args ->
-                                     IO [NDArrayHandle]
-_backward__contrib_MultiBoxPrior args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiBoxPrior_upd ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)"
-                                         args =>
-                                       [NDArrayHandle] ->
-                                         ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args
-                                           -> IO ()
-_backward__contrib_MultiBoxPrior_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiProposal(ndarray)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle),
-        '("bbox_pred", AttrOpt NDArrayHandle),
-        '("im_info", AttrOpt NDArrayHandle)]
-
-_contrib_MultiProposal ::
-                       forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args =>
-                         ArgsHMap "_contrib_MultiProposal(ndarray)" args ->
-                           IO [NDArrayHandle]
-_contrib_MultiProposal args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiProposal_upd ::
-                           forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_contrib_MultiProposal(ndarray)" args -> IO ()
-_contrib_MultiProposal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiProposal(ndarray)" = '[]
-
-_backward__contrib_MultiProposal ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiProposal(ndarray)" args =>
-                                   ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args ->
-                                     IO [NDArrayHandle]
-_backward__contrib_MultiProposal args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiProposal_upd ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiProposal(ndarray)"
-                                         args =>
-                                       [NDArrayHandle] ->
-                                         ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args
-                                           -> IO ()
-_backward__contrib_MultiProposal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_PSROIPooling(ndarray)" = '[]
-
-_backward__contrib_PSROIPooling ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args =>
-                                  ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args ->
-                                    IO [NDArrayHandle]
-_backward__contrib_PSROIPooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_PSROIPooling_upd ::
-                                    forall args .
-                                      Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args =>
-                                      [NDArrayHandle] ->
-                                        ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args ->
-                                          IO ()
-_backward__contrib_PSROIPooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_contrib_DeformableConvolution(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("num_deformable_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("offset", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_contrib_DeformableConvolution ::
-                               forall args .
-                                 Fullfilled "_contrib_DeformableConvolution(ndarray)" args =>
-                                 ArgsHMap "_contrib_DeformableConvolution(ndarray)" args ->
-                                   IO [NDArrayHandle]
-_contrib_DeformableConvolution args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("num_deformable_group",) . showValue <$>
-                 (args !? #num_deformable_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_DeformableConvolution_upd ::
-                                   forall args .
-                                     Fullfilled "_contrib_DeformableConvolution(ndarray)" args =>
-                                     [NDArrayHandle] ->
-                                       ArgsHMap "_contrib_DeformableConvolution(ndarray)" args ->
-                                         IO ()
-_contrib_DeformableConvolution_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("num_deformable_group",) . showValue <$>
-                 (args !? #num_deformable_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_DeformableConvolution(ndarray)" =
-     '[]
-
-_backward__contrib_DeformableConvolution ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward__contrib_DeformableConvolution(ndarray)"
-                                             args =>
-                                           ArgsHMap
-                                             "_backward__contrib_DeformableConvolution(ndarray)"
-                                             args
-                                             -> IO [NDArrayHandle]
-_backward__contrib_DeformableConvolution args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_DeformableConvolution_upd ::
-                                             forall args .
-                                               Fullfilled
-                                                 "_backward__contrib_DeformableConvolution(ndarray)"
-                                                 args =>
-                                               [NDArrayHandle] ->
-                                                 ArgsHMap
-                                                   "_backward__contrib_DeformableConvolution(ndarray)"
-                                                   args
-                                                   -> IO ()
-_backward__contrib_DeformableConvolution_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_ifft(ndarray)" =
-     '[ '("compute_size", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_ifft ::
-              forall args . Fullfilled "_contrib_ifft(ndarray)" args =>
-                ArgsHMap "_contrib_ifft(ndarray)" args -> IO [NDArrayHandle]
-_contrib_ifft args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_ifft_upd ::
-                  forall args . Fullfilled "_contrib_ifft(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_contrib_ifft(ndarray)" args -> IO ()
-_contrib_ifft_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__contrib_ifft(ndarray)" =
-     '[]
-
-_backward__contrib_ifft ::
-                        forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args =>
-                          ArgsHMap "_backward__contrib_ifft(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward__contrib_ifft args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_ifft_upd ::
-                            forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward__contrib_ifft(ndarray)" args -> IO ()
-_backward__contrib_ifft_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_SyncBatchNorm(ndarray)" = '[]
-
-_backward__contrib_SyncBatchNorm ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)" args =>
-                                   ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args ->
-                                     IO [NDArrayHandle]
-_backward__contrib_SyncBatchNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_SyncBatchNorm_upd ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)"
-                                         args =>
-                                       [NDArrayHandle] ->
-                                         ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args
-                                           -> IO ()
-_backward__contrib_SyncBatchNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_InstanceNorm(ndarray)" =
-     '[ '("eps", AttrOpt Float), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_InstanceNorm ::
-              forall args . Fullfilled "_InstanceNorm(ndarray)" args =>
-                ArgsHMap "_InstanceNorm(ndarray)" args -> IO [NDArrayHandle]
-_InstanceNorm args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_InstanceNorm_upd ::
-                  forall args . Fullfilled "_InstanceNorm(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_InstanceNorm(ndarray)" args -> IO ()
-_InstanceNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_InstanceNorm(ndarray)" = '[]
-
-_backward_InstanceNorm ::
-                       forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args =>
-                         ArgsHMap "_backward_InstanceNorm(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_InstanceNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_InstanceNorm_upd ::
-                           forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_InstanceNorm(ndarray)" args -> IO ()
-_backward_InstanceNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SVMOutput(ndarray)" =
-     '[ '("margin", AttrOpt Float),
-        '("regularization_coefficient", AttrOpt Float),
-        '("use_linear", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_SVMOutput ::
-           forall args . Fullfilled "_SVMOutput(ndarray)" args =>
-             ArgsHMap "_SVMOutput(ndarray)" args -> IO [NDArrayHandle]
-_SVMOutput args
-  = let scalarArgs
-          = catMaybes
-              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),
-               ("regularization_coefficient",) . showValue <$>
-                 (args !? #regularization_coefficient :: Maybe Float),
-               ("use_linear",) . showValue <$>
-                 (args !? #use_linear :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SVMOutput_upd ::
-               forall args . Fullfilled "_SVMOutput(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_SVMOutput(ndarray)" args -> IO ()
-_SVMOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),
-               ("regularization_coefficient",) . showValue <$>
-                 (args !? #regularization_coefficient :: Maybe Float),
-               ("use_linear",) . showValue <$>
-                 (args !? #use_linear :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SVMOutput(ndarray)" = '[]
-
-_backward_SVMOutput ::
-                    forall args . Fullfilled "_backward_SVMOutput(ndarray)" args =>
-                      ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO [NDArrayHandle]
-_backward_SVMOutput args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SVMOutput_upd ::
-                        forall args . Fullfilled "_backward_SVMOutput(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO ()
-_backward_SVMOutput_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_GridGenerator(ndarray)" =
-     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),
-        '("target_shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-_GridGenerator ::
-               forall args . Fullfilled "_GridGenerator(ndarray)" args =>
-                 ArgsHMap "_GridGenerator(ndarray)" args -> IO [NDArrayHandle]
-_GridGenerator args
-  = let scalarArgs
-          = catMaybes
-              [("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_GridGenerator_upd ::
-                   forall args . Fullfilled "_GridGenerator(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_GridGenerator(ndarray)" args -> IO ()
-_GridGenerator_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_GridGenerator(ndarray)" =
-     '[]
-
-_backward_GridGenerator ::
-                        forall args . Fullfilled "_backward_GridGenerator(ndarray)" args =>
-                          ArgsHMap "_backward_GridGenerator(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_GridGenerator args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_GridGenerator_upd ::
-                            forall args . Fullfilled "_backward_GridGenerator(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_GridGenerator(ndarray)" args -> IO ()
-_backward_GridGenerator_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Pad(ndarray)" = '[]
-
-_backward_Pad ::
-              forall args . Fullfilled "_backward_Pad(ndarray)" args =>
-                ArgsHMap "_backward_Pad(ndarray)" args -> IO [NDArrayHandle]
-_backward_Pad args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Pad_upd ::
-                  forall args . Fullfilled "_backward_Pad(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_Pad(ndarray)" args -> IO ()
-_backward_Pad_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Convolution_v1(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_Convolution_v1 ::
-                forall args . Fullfilled "_Convolution_v1(ndarray)" args =>
-                  ArgsHMap "_Convolution_v1(ndarray)" args -> IO [NDArrayHandle]
-_Convolution_v1 args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Convolution_v1_upd ::
-                    forall args . Fullfilled "_Convolution_v1(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_Convolution_v1(ndarray)" args -> IO ()
-_Convolution_v1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Convolution_v1(ndarray)" =
-     '[]
-
-_backward_Convolution_v1 ::
-                         forall args .
-                           Fullfilled "_backward_Convolution_v1(ndarray)" args =>
-                           ArgsHMap "_backward_Convolution_v1(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_Convolution_v1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Convolution_v1_upd ::
-                             forall args .
-                               Fullfilled "_backward_Convolution_v1(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_Convolution_v1(ndarray)" args -> IO ()
-_backward_Convolution_v1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SequenceReverse(ndarray)" =
-     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle),
-        '("sequence_length", AttrOpt NDArrayHandle)]
-
-_SequenceReverse ::
-                 forall args . Fullfilled "_SequenceReverse(ndarray)" args =>
-                   ArgsHMap "_SequenceReverse(ndarray)" args -> IO [NDArrayHandle]
-_SequenceReverse args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SequenceReverse_upd ::
-                     forall args . Fullfilled "_SequenceReverse(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_SequenceReverse(ndarray)" args -> IO ()
-_SequenceReverse_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SequenceReverse(ndarray)" =
-     '[]
-
-_backward_SequenceReverse ::
-                          forall args .
-                            Fullfilled "_backward_SequenceReverse(ndarray)" args =>
-                            ArgsHMap "_backward_SequenceReverse(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_SequenceReverse args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SequenceReverse_upd ::
-                              forall args .
-                                Fullfilled "_backward_SequenceReverse(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_SequenceReverse(ndarray)" args -> IO ()
-_backward_SequenceReverse_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SoftmaxOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
-        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_SoftmaxOutput ::
-               forall args . Fullfilled "_SoftmaxOutput(ndarray)" args =>
-                 ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO [NDArrayHandle]
-_SoftmaxOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SoftmaxOutput_upd ::
-                   forall args . Fullfilled "_SoftmaxOutput(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO ()
-_SoftmaxOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SoftmaxOutput(ndarray)" =
-     '[]
-
-_backward_SoftmaxOutput ::
-                        forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args =>
-                          ArgsHMap "_backward_SoftmaxOutput(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_SoftmaxOutput args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SoftmaxOutput_upd ::
-                            forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> IO ()
-_backward_SoftmaxOutput_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Softmax(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
-        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Softmax ::
-         forall args . Fullfilled "_Softmax(ndarray)" args =>
-           ArgsHMap "_Softmax(ndarray)" args -> IO [NDArrayHandle]
-_Softmax args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Softmax_upd ::
-             forall args . Fullfilled "_Softmax(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Softmax(ndarray)" args -> IO ()
-_Softmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Softmax(ndarray)" = '[]
-
-_backward_Softmax ::
-                  forall args . Fullfilled "_backward_Softmax(ndarray)" args =>
-                    ArgsHMap "_backward_Softmax(ndarray)" args -> IO [NDArrayHandle]
-_backward_Softmax args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Softmax_upd ::
-                      forall args . Fullfilled "_backward_Softmax(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_Softmax(ndarray)" args -> IO ()
-_backward_Softmax_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BilinearSampler(ndarray)" =
-     '[ '("cudnn_off", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt NDArrayHandle), '("grid", AttrOpt NDArrayHandle)]
-
-_BilinearSampler ::
-                 forall args . Fullfilled "_BilinearSampler(ndarray)" args =>
-                   ArgsHMap "_BilinearSampler(ndarray)" args -> IO [NDArrayHandle]
-_BilinearSampler args
-  = let scalarArgs
-          = catMaybes
-              [("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BilinearSampler_upd ::
-                     forall args . Fullfilled "_BilinearSampler(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_BilinearSampler(ndarray)" args -> IO ()
-_BilinearSampler_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_BilinearSampler(ndarray)" =
-     '[]
-
-_backward_BilinearSampler ::
-                          forall args .
-                            Fullfilled "_backward_BilinearSampler(ndarray)" args =>
-                            ArgsHMap "_backward_BilinearSampler(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_BilinearSampler args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_BilinearSampler_upd ::
-                              forall args .
-                                Fullfilled "_backward_BilinearSampler(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_BilinearSampler(ndarray)" args -> IO ()
-_backward_BilinearSampler_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_LeakyReLU(ndarray)" = '[]
-
-_backward_LeakyReLU ::
-                    forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args =>
-                      ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO [NDArrayHandle]
-_backward_LeakyReLU args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_LeakyReLU_upd ::
-                        forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO ()
-_backward_LeakyReLU_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Crop(ndarray)" =
-     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),
-        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_Crop ::
-      forall args . Fullfilled "_Crop(ndarray)" args =>
-        ArgsHMap "_Crop(ndarray)" args -> IO [NDArrayHandle]
-_Crop args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),
-               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),
-               ("center_crop",) . showValue <$>
-                 (args !? #center_crop :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Crop"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_Crop_upd ::
-          forall args . Fullfilled "_Crop(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_Crop(ndarray)" args -> IO ()
-_Crop_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),
-               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),
-               ("center_crop",) . showValue <$>
-                 (args !? #center_crop :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Crop"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Crop(ndarray)" = '[]
-
-_backward_Crop ::
-               forall args . Fullfilled "_backward_Crop(ndarray)" args =>
-                 ArgsHMap "_backward_Crop(ndarray)" args -> IO [NDArrayHandle]
-_backward_Crop args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Crop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Crop_upd ::
-                   forall args . Fullfilled "_backward_Crop(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_Crop(ndarray)" args -> IO ()
-_backward_Crop_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Crop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_ROIPooling(ndarray)" =
-     '[ '("pooled_size", AttrReq [Int]),
-        '("spatial_scale", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)]
-
-_ROIPooling ::
-            forall args . Fullfilled "_ROIPooling(ndarray)" args =>
-              ArgsHMap "_ROIPooling(ndarray)" args -> IO [NDArrayHandle]
-_ROIPooling args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_ROIPooling_upd ::
-                forall args . Fullfilled "_ROIPooling(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_ROIPooling(ndarray)" args -> IO ()
-_ROIPooling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_ROIPooling(ndarray)" = '[]
-
-_backward_ROIPooling ::
-                     forall args . Fullfilled "_backward_ROIPooling(ndarray)" args =>
-                       ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO [NDArrayHandle]
-_backward_ROIPooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_ROIPooling_upd ::
-                         forall args . Fullfilled "_backward_ROIPooling(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO ()
-_backward_ROIPooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SequenceLast(ndarray)" =
-     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle),
-        '("sequence_length", AttrOpt NDArrayHandle)]
-
-_SequenceLast ::
-              forall args . Fullfilled "_SequenceLast(ndarray)" args =>
-                ArgsHMap "_SequenceLast(ndarray)" args -> IO [NDArrayHandle]
-_SequenceLast args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SequenceLast_upd ::
-                  forall args . Fullfilled "_SequenceLast(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_SequenceLast(ndarray)" args -> IO ()
-_SequenceLast_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SequenceLast(ndarray)" = '[]
-
-_backward_SequenceLast ::
-                       forall args . Fullfilled "_backward_SequenceLast(ndarray)" args =>
-                         ArgsHMap "_backward_SequenceLast(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_SequenceLast args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SequenceLast_upd ::
-                           forall args . Fullfilled "_backward_SequenceLast(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_SequenceLast(ndarray)" args -> IO ()
-_backward_SequenceLast_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CrossDeviceCopy(ndarray)" = '[]
-
-_CrossDeviceCopy ::
-                 forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args =>
-                   ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO [NDArrayHandle]
-_CrossDeviceCopy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CrossDeviceCopy_upd ::
-                     forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO ()
-_CrossDeviceCopy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__CrossDeviceCopy(ndarray)" =
-     '[]
-
-_backward__CrossDeviceCopy ::
-                           forall args .
-                             Fullfilled "_backward__CrossDeviceCopy(ndarray)" args =>
-                             ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args ->
-                               IO [NDArrayHandle]
-_backward__CrossDeviceCopy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__CrossDeviceCopy_upd ::
-                               forall args .
-                                 Fullfilled "_backward__CrossDeviceCopy(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> IO ()
-_backward__CrossDeviceCopy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SpatialTransformer(ndarray)" =
-     '[ '("target_shape", AttrOpt [Int]),
-        '("transform_type", AttrReq (EnumType '["affine"])),
-        '("sampler_type", AttrReq (EnumType '["bilinear"])),
-        '("cudnn_off", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt NDArrayHandle), '("loc", AttrOpt NDArrayHandle)]
-
-_SpatialTransformer ::
-                    forall args . Fullfilled "_SpatialTransformer(ndarray)" args =>
-                      ArgsHMap "_SpatialTransformer(ndarray)" args -> IO [NDArrayHandle]
-_SpatialTransformer args
-  = let scalarArgs
-          = catMaybes
-              [("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine"])),
-               ("sampler_type",) . showValue <$>
-                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"])),
-               ("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SpatialTransformer_upd ::
-                        forall args . Fullfilled "_SpatialTransformer(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_SpatialTransformer(ndarray)" args -> IO ()
-_SpatialTransformer_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine"])),
-               ("sampler_type",) . showValue <$>
-                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"])),
-               ("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SpatialTransformer(ndarray)"
-     = '[]
-
-_backward_SpatialTransformer ::
-                             forall args .
-                               Fullfilled "_backward_SpatialTransformer(ndarray)" args =>
-                               ArgsHMap "_backward_SpatialTransformer(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_backward_SpatialTransformer args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SpatialTransformer_upd ::
-                                 forall args .
-                                   Fullfilled "_backward_SpatialTransformer(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> IO ()
-_backward_SpatialTransformer_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SwapAxis(ndarray)" = '[]
-
-_backward_SwapAxis ::
-                   forall args . Fullfilled "_backward_SwapAxis(ndarray)" args =>
-                     ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO [NDArrayHandle]
-_backward_SwapAxis args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SwapAxis_upd ::
-                       forall args . Fullfilled "_backward_SwapAxis(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO ()
-_backward_SwapAxis_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_L2Normalization(ndarray)" =
-     '[ '("eps", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_L2Normalization ::
-                 forall args . Fullfilled "_L2Normalization(ndarray)" args =>
-                   ArgsHMap "_L2Normalization(ndarray)" args -> IO [NDArrayHandle]
-_L2Normalization args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["channel", "instance", "spatial"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_L2Normalization_upd ::
-                     forall args . Fullfilled "_L2Normalization(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_L2Normalization(ndarray)" args -> IO ()
-_L2Normalization_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["channel", "instance", "spatial"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_L2Normalization(ndarray)" =
-     '[]
-
-_backward_L2Normalization ::
-                          forall args .
-                            Fullfilled "_backward_L2Normalization(ndarray)" args =>
-                            ArgsHMap "_backward_L2Normalization(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_L2Normalization args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_L2Normalization_upd ::
-                              forall args .
-                                Fullfilled "_backward_L2Normalization(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_L2Normalization(ndarray)" args -> IO ()
-_backward_L2Normalization_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Correlation(ndarray)" =
-     '[ '("kernel_size", AttrOpt Int),
-        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),
-        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),
-        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt NDArrayHandle),
-        '("data2", AttrOpt NDArrayHandle)]
-
-_Correlation ::
-             forall args . Fullfilled "_Correlation(ndarray)" args =>
-               ArgsHMap "_Correlation(ndarray)" args -> IO [NDArrayHandle]
-_Correlation args
-  = let scalarArgs
-          = catMaybes
-              [("kernel_size",) . showValue <$>
-                 (args !? #kernel_size :: Maybe Int),
-               ("max_displacement",) . showValue <$>
-                 (args !? #max_displacement :: Maybe Int),
-               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),
-               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),
-               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),
-               ("is_multiply",) . showValue <$>
-                 (args !? #is_multiply :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle),
-               ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Correlation_upd ::
-                 forall args . Fullfilled "_Correlation(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_Correlation(ndarray)" args -> IO ()
-_Correlation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel_size",) . showValue <$>
-                 (args !? #kernel_size :: Maybe Int),
-               ("max_displacement",) . showValue <$>
-                 (args !? #max_displacement :: Maybe Int),
-               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),
-               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),
-               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),
-               ("is_multiply",) . showValue <$>
-                 (args !? #is_multiply :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle),
-               ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Correlation(ndarray)" = '[]
-
-_backward_Correlation ::
-                      forall args . Fullfilled "_backward_Correlation(ndarray)" args =>
-                        ArgsHMap "_backward_Correlation(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_Correlation args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Correlation_upd ::
-                          forall args . Fullfilled "_backward_Correlation(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_Correlation(ndarray)" args -> IO ()
-_backward_Correlation_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_IdentityAttachKLSparseReg(ndarray)" = '[]
-
-_backward_IdentityAttachKLSparseReg ::
-                                    forall args .
-                                      Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)"
-                                        args =>
-                                      ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" args
-                                        -> IO [NDArrayHandle]
-_backward_IdentityAttachKLSparseReg args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_IdentityAttachKLSparseReg_upd ::
-                                        forall args .
-                                          Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)"
-                                            args =>
-                                          [NDArrayHandle] ->
-                                            ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)"
-                                              args
-                                              -> IO ()
-_backward_IdentityAttachKLSparseReg_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_MakeLoss(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_MakeLoss ::
-          forall args . Fullfilled "_MakeLoss(ndarray)" args =>
-            ArgsHMap "_MakeLoss(ndarray)" args -> IO [NDArrayHandle]
-_MakeLoss args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_MakeLoss_upd ::
-              forall args . Fullfilled "_MakeLoss(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_MakeLoss(ndarray)" args -> IO ()
-_MakeLoss_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_MakeLoss(ndarray)" = '[]
-
-_backward_MakeLoss ::
-                   forall args . Fullfilled "_backward_MakeLoss(ndarray)" args =>
-                     ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO [NDArrayHandle]
-_backward_MakeLoss args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_MakeLoss_upd ::
-                       forall args . Fullfilled "_backward_MakeLoss(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO ()
-_backward_MakeLoss_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SliceChannel(ndarray)" = '[]
-
-_backward_SliceChannel ::
-                       forall args . Fullfilled "_backward_SliceChannel(ndarray)" args =>
-                         ArgsHMap "_backward_SliceChannel(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_SliceChannel args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SliceChannel_upd ::
-                           forall args . Fullfilled "_backward_SliceChannel(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_SliceChannel(ndarray)" args -> IO ()
-_backward_SliceChannel_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_RNN(ndarray)" =
-     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),
-        '("bidirectional", AttrOpt Bool),
-        '("mode",
-          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),
-        '("projection_size", AttrOpt (Maybe Int)),
-        '("lstm_state_clip_min", AttrOpt (Maybe Double)),
-        '("lstm_state_clip_max", AttrOpt (Maybe Double)),
-        '("lstm_state_clip_nan", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle),
-        '("parameters", AttrOpt NDArrayHandle),
-        '("state", AttrOpt NDArrayHandle),
-        '("state_cell", AttrOpt NDArrayHandle)]
-
-_RNN ::
-     forall args . Fullfilled "_RNN(ndarray)" args =>
-       ArgsHMap "_RNN(ndarray)" args -> IO [NDArrayHandle]
-_RNN args
-  = let scalarArgs
-          = catMaybes
-              [("state_size",) . showValue <$>
-                 (args !? #state_size :: Maybe Int),
-               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),
-               ("bidirectional",) . showValue <$>
-                 (args !? #bidirectional :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("state_outputs",) . showValue <$>
-                 (args !? #state_outputs :: Maybe Bool),
-               ("projection_size",) . showValue <$>
-                 (args !? #projection_size :: Maybe (Maybe Int)),
-               ("lstm_state_clip_min",) . showValue <$>
-                 (args !? #lstm_state_clip_min :: Maybe (Maybe Double)),
-               ("lstm_state_clip_max",) . showValue <$>
-                 (args !? #lstm_state_clip_max :: Maybe (Maybe Double)),
-               ("lstm_state_clip_nan",) . showValue <$>
-                 (args !? #lstm_state_clip_nan :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle),
-               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),
-               ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_RNN_upd ::
-         forall args . Fullfilled "_RNN(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_RNN(ndarray)" args -> IO ()
-_RNN_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("state_size",) . showValue <$>
-                 (args !? #state_size :: Maybe Int),
-               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),
-               ("bidirectional",) . showValue <$>
-                 (args !? #bidirectional :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("state_outputs",) . showValue <$>
-                 (args !? #state_outputs :: Maybe Bool),
-               ("projection_size",) . showValue <$>
-                 (args !? #projection_size :: Maybe (Maybe Int)),
-               ("lstm_state_clip_min",) . showValue <$>
-                 (args !? #lstm_state_clip_min :: Maybe (Maybe Double)),
-               ("lstm_state_clip_max",) . showValue <$>
-                 (args !? #lstm_state_clip_max :: Maybe (Maybe Double)),
-               ("lstm_state_clip_nan",) . showValue <$>
-                 (args !? #lstm_state_clip_nan :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle),
-               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),
-               ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_RNN(ndarray)" = '[]
-
-_backward_RNN ::
-              forall args . Fullfilled "_backward_RNN(ndarray)" args =>
-                ArgsHMap "_backward_RNN(ndarray)" args -> IO [NDArrayHandle]
-_backward_RNN args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_RNN_upd ::
-                  forall args . Fullfilled "_backward_RNN(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_RNN(ndarray)" args -> IO ()
-_backward_RNN_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Pooling_v1(ndarray)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])),
-        '("global_pool", AttrOpt Bool),
-        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Pooling_v1 ::
-            forall args . Fullfilled "_Pooling_v1(ndarray)" args =>
-              ArgsHMap "_Pooling_v1(ndarray)" args -> IO [NDArrayHandle]
-_Pooling_v1 args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Pooling_v1_upd ::
-                forall args . Fullfilled "_Pooling_v1(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_Pooling_v1(ndarray)" args -> IO ()
-_Pooling_v1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Pooling_v1(ndarray)" = '[]
-
-_backward_Pooling_v1 ::
-                     forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args =>
-                       ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO [NDArrayHandle]
-_backward_Pooling_v1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Pooling_v1_upd ::
-                         forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO ()
-_backward_Pooling_v1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_BatchNorm_v1(ndarray)" = '[]
-
-_backward_BatchNorm_v1 ::
-                       forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args =>
-                         ArgsHMap "_backward_BatchNorm_v1(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_BatchNorm_v1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_BatchNorm_v1_upd ::
-                           forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> IO ()
-_backward_BatchNorm_v1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SequenceMask(ndarray)" =
-     '[ '("use_sequence_length", AttrOpt Bool),
-        '("value", AttrOpt Float), '("axis", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle),
-        '("sequence_length", AttrOpt NDArrayHandle)]
-
-_SequenceMask ::
-              forall args . Fullfilled "_SequenceMask(ndarray)" args =>
-                ArgsHMap "_SequenceMask(ndarray)" args -> IO [NDArrayHandle]
-_SequenceMask args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("value",) . showValue <$> (args !? #value :: Maybe Float),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SequenceMask_upd ::
-                  forall args . Fullfilled "_SequenceMask(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_SequenceMask(ndarray)" args -> IO ()
-_SequenceMask_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("value",) . showValue <$> (args !? #value :: Maybe Float),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SequenceMask(ndarray)" = '[]
-
-_backward_SequenceMask ::
-                       forall args . Fullfilled "_backward_SequenceMask(ndarray)" args =>
-                         ArgsHMap "_backward_SequenceMask(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_SequenceMask args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SequenceMask_upd ::
-                           forall args . Fullfilled "_backward_SequenceMask(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_SequenceMask(ndarray)" args -> IO ()
-_backward_SequenceMask_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_set_value(ndarray)" =
-     '[ '("src", AttrOpt Float)]
-
-_set_value ::
-           forall args . Fullfilled "_set_value(ndarray)" args =>
-             ArgsHMap "_set_value(ndarray)" args -> IO [NDArrayHandle]
-_set_value args
-  = let scalarArgs
-          = catMaybes
-              [("src",) . showValue <$> (args !? #src :: Maybe Float)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_set_value"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_set_value_upd ::
-               forall args . Fullfilled "_set_value(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_set_value(ndarray)" args -> IO ()
-_set_value_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("src",) . showValue <$> (args !? #src :: Maybe Float)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_set_value"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_onehot_encode(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_onehot_encode ::
-               forall args . Fullfilled "_onehot_encode(ndarray)" args =>
-                 ArgsHMap "_onehot_encode(ndarray)" args -> IO [NDArrayHandle]
-_onehot_encode args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_onehot_encode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_onehot_encode_upd ::
-                   forall args . Fullfilled "_onehot_encode(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_onehot_encode(ndarray)" args -> IO ()
-_onehot_encode_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_onehot_encode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "choose_element_0index(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-choose_element_0index ::
-                      forall args . Fullfilled "choose_element_0index(ndarray)" args =>
-                        ArgsHMap "choose_element_0index(ndarray)" args ->
-                          IO [NDArrayHandle]
-choose_element_0index args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "choose_element_0index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-choose_element_0index_upd ::
-                          forall args . Fullfilled "choose_element_0index(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "choose_element_0index(ndarray)" args -> IO ()
-choose_element_0index_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "choose_element_0index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "fill_element_0index(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("mhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-fill_element_0index ::
-                    forall args . Fullfilled "fill_element_0index(ndarray)" args =>
-                      ArgsHMap "fill_element_0index(ndarray)" args -> IO [NDArrayHandle]
-fill_element_0index args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fill_element_0index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-fill_element_0index_upd ::
-                        forall args . Fullfilled "fill_element_0index(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "fill_element_0index(ndarray)" args -> IO ()
-fill_element_0index_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fill_element_0index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_imdecode(ndarray)" =
-     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),
-        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),
-        '("c", AttrOpt Int), '("size", AttrOpt Int),
-        '("mean", AttrOpt NDArrayHandle)]
-
-_imdecode ::
-          forall args . Fullfilled "_imdecode(ndarray)" args =>
-            ArgsHMap "_imdecode(ndarray)" args -> IO [NDArrayHandle]
-_imdecode args
-  = let scalarArgs
-          = catMaybes
-              [("index",) . showValue <$> (args !? #index :: Maybe Int),
-               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),
-               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),
-               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),
-               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),
-               ("c",) . showValue <$> (args !? #c :: Maybe Int),
-               ("size",) . showValue <$> (args !? #size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_imdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_imdecode_upd ::
-              forall args . Fullfilled "_imdecode(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_imdecode(ndarray)" args -> IO ()
-_imdecode_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("index",) . showValue <$> (args !? #index :: Maybe Int),
-               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),
-               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),
-               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),
-               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),
-               ("c",) . showValue <$> (args !? #c :: Maybe Int),
-               ("size",) . showValue <$> (args !? #size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_imdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
diff --git a/ops/1.4/MXNet/Base/Operators/Symbol.hs b/ops/1.4/MXNet/Base/Operators/Symbol.hs
deleted file mode 100644
--- a/ops/1.4/MXNet/Base/Operators/Symbol.hs
+++ /dev/null
@@ -1,12038 +0,0 @@
-module MXNet.Base.Operators.Symbol where
-import MXNet.Base.Raw
-import MXNet.Base.Spec.Operator
-import MXNet.Base.Spec.HMap
-import Data.Maybe (catMaybes, fromMaybe)
-
-type instance ParameterList "_CuDNNBatchNorm(symbol)" =
-     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),
-        '("moving_mean", AttrOpt SymbolHandle),
-        '("moving_var", AttrOpt SymbolHandle)]
-
-_CuDNNBatchNorm ::
-                forall args . Fullfilled "_CuDNNBatchNorm(symbol)" args =>
-                  String ->
-                    ArgsHMap "_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle
-_CuDNNBatchNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CuDNNBatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_CuDNNBatchNorm(symbol)" =
-     '[]
-
-_backward_CuDNNBatchNorm ::
-                         forall args . Fullfilled "_backward_CuDNNBatchNorm(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle
-_backward_CuDNNBatchNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_multinomial(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_sample_multinomial ::
-                    forall args . Fullfilled "_sample_multinomial(symbol)" args =>
-                      String ->
-                        ArgsHMap "_sample_multinomial(symbol)" args -> IO SymbolHandle
-_sample_multinomial name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_multinomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sample_multinomial(symbol)"
-     = '[]
-
-_backward_sample_multinomial ::
-                             forall args .
-                               Fullfilled "_backward_sample_multinomial(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_backward_sample_multinomial(symbol)" args ->
-                                   IO SymbolHandle
-_backward_sample_multinomial name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sample_multinomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_uniform(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("low", AttrOpt SymbolHandle), '("high", AttrOpt SymbolHandle)]
-
-_sample_uniform ::
-                forall args . Fullfilled "_sample_uniform(symbol)" args =>
-                  String ->
-                    ArgsHMap "_sample_uniform(symbol)" args -> IO SymbolHandle
-_sample_uniform name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("low",) <$> (args !? #low :: Maybe SymbolHandle),
-               ("high",) <$> (args !? #high :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_uniform"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_normal(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt SymbolHandle), '("sigma", AttrOpt SymbolHandle)]
-
-_sample_normal ::
-               forall args . Fullfilled "_sample_normal(symbol)" args =>
-                 String -> ArgsHMap "_sample_normal(symbol)" args -> IO SymbolHandle
-_sample_normal name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),
-               ("sigma",) <$> (args !? #sigma :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_normal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_gamma(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]
-
-_sample_gamma ::
-              forall args . Fullfilled "_sample_gamma(symbol)" args =>
-                String -> ArgsHMap "_sample_gamma(symbol)" args -> IO SymbolHandle
-_sample_gamma name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_exponential(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt SymbolHandle)]
-
-_sample_exponential ::
-                    forall args . Fullfilled "_sample_exponential(symbol)" args =>
-                      String ->
-                        ArgsHMap "_sample_exponential(symbol)" args -> IO SymbolHandle
-_sample_exponential name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_exponential"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_poisson(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt SymbolHandle)]
-
-_sample_poisson ::
-                forall args . Fullfilled "_sample_poisson(symbol)" args =>
-                  String ->
-                    ArgsHMap "_sample_poisson(symbol)" args -> IO SymbolHandle
-_sample_poisson name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_poisson"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_negative_binomial(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("k", AttrOpt SymbolHandle), '("p", AttrOpt SymbolHandle)]
-
-_sample_negative_binomial ::
-                          forall args .
-                            Fullfilled "_sample_negative_binomial(symbol)" args =>
-                            String ->
-                              ArgsHMap "_sample_negative_binomial(symbol)" args ->
-                                IO SymbolHandle
-_sample_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("k",) <$> (args !? #k :: Maybe SymbolHandle),
-               ("p",) <$> (args !? #p :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_sample_generalized_negative_binomial(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt SymbolHandle), '("alpha", AttrOpt SymbolHandle)]
-
-_sample_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_sample_generalized_negative_binomial(symbol)"
-                                          args =>
-                                        String ->
-                                          ArgsHMap "_sample_generalized_negative_binomial(symbol)"
-                                            args
-                                            -> IO SymbolHandle
-_sample_generalized_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_unique_zipfian(symbol)" =
-     '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])]
-
-_sample_unique_zipfian ::
-                       forall args . Fullfilled "_sample_unique_zipfian(symbol)" args =>
-                         String ->
-                           ArgsHMap "_sample_unique_zipfian(symbol)" args -> IO SymbolHandle
-_sample_unique_zipfian name args
-  = let scalarArgs
-          = catMaybes
-              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_unique_zipfian"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_uniform(symbol)" =
-     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_uniform ::
-                forall args . Fullfilled "_random_uniform(symbol)" args =>
-                  String ->
-                    ArgsHMap "_random_uniform(symbol)" args -> IO SymbolHandle
-_random_uniform name args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_normal(symbol)" =
-     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_normal ::
-               forall args . Fullfilled "_random_normal(symbol)" args =>
-                 String -> ArgsHMap "_random_normal(symbol)" args -> IO SymbolHandle
-_random_normal name args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_gamma(symbol)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_gamma ::
-              forall args . Fullfilled "_random_gamma(symbol)" args =>
-                String -> ArgsHMap "_random_gamma(symbol)" args -> IO SymbolHandle
-_random_gamma name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_exponential(symbol)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_exponential ::
-                    forall args . Fullfilled "_random_exponential(symbol)" args =>
-                      String ->
-                        ArgsHMap "_random_exponential(symbol)" args -> IO SymbolHandle
-_random_exponential name args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_poisson(symbol)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_poisson ::
-                forall args . Fullfilled "_random_poisson(symbol)" args =>
-                  String ->
-                    ArgsHMap "_random_poisson(symbol)" args -> IO SymbolHandle
-_random_poisson name args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_negative_binomial(symbol)" =
-     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_negative_binomial ::
-                          forall args .
-                            Fullfilled "_random_negative_binomial(symbol)" args =>
-                            String ->
-                              ArgsHMap "_random_negative_binomial(symbol)" args ->
-                                IO SymbolHandle
-_random_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_random_generalized_negative_binomial(symbol)" =
-     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_random_generalized_negative_binomial(symbol)"
-                                          args =>
-                                        String ->
-                                          ArgsHMap "_random_generalized_negative_binomial(symbol)"
-                                            args
-                                            -> IO SymbolHandle
-_random_generalized_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_randint(symbol)" =
-     '[ '("low", AttrReq Int), '("high", AttrReq Int),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype", AttrOpt (EnumType '["None", "int32", "int64"]))]
-
-_random_randint ::
-                forall args . Fullfilled "_random_randint(symbol)" args =>
-                  String ->
-                    ArgsHMap "_random_randint(symbol)" args -> IO SymbolHandle
-_random_randint name args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Int),
-               ("high",) . showValue <$> (args !? #high :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_randint"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_uniform_like(symbol)" =
-     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_random_uniform_like ::
-                     forall args . Fullfilled "_random_uniform_like(symbol)" args =>
-                       String ->
-                         ArgsHMap "_random_uniform_like(symbol)" args -> IO SymbolHandle
-_random_uniform_like name args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_normal_like(symbol)" =
-     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_random_normal_like ::
-                    forall args . Fullfilled "_random_normal_like(symbol)" args =>
-                      String ->
-                        ArgsHMap "_random_normal_like(symbol)" args -> IO SymbolHandle
-_random_normal_like name args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_gamma_like(symbol)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_random_gamma_like ::
-                   forall args . Fullfilled "_random_gamma_like(symbol)" args =>
-                     String ->
-                       ArgsHMap "_random_gamma_like(symbol)" args -> IO SymbolHandle
-_random_gamma_like name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_exponential_like(symbol)" =
-     '[ '("lam", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_random_exponential_like ::
-                         forall args . Fullfilled "_random_exponential_like(symbol)" args =>
-                           String ->
-                             ArgsHMap "_random_exponential_like(symbol)" args -> IO SymbolHandle
-_random_exponential_like name args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_poisson_like(symbol)" =
-     '[ '("lam", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_random_poisson_like ::
-                     forall args . Fullfilled "_random_poisson_like(symbol)" args =>
-                       String ->
-                         ArgsHMap "_random_poisson_like(symbol)" args -> IO SymbolHandle
-_random_poisson_like name args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_random_negative_binomial_like(symbol)" =
-     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_random_negative_binomial_like ::
-                               forall args .
-                                 Fullfilled "_random_negative_binomial_like(symbol)" args =>
-                                 String ->
-                                   ArgsHMap "_random_negative_binomial_like(symbol)" args ->
-                                     IO SymbolHandle
-_random_negative_binomial_like name args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_random_generalized_negative_binomial_like(symbol)"
-     =
-     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_random_generalized_negative_binomial_like ::
-                                           forall args .
-                                             Fullfilled
-                                               "_random_generalized_negative_binomial_like(symbol)"
-                                               args =>
-                                             String ->
-                                               ArgsHMap
-                                                 "_random_generalized_negative_binomial_like(symbol)"
-                                                 args
-                                                 -> IO SymbolHandle
-_random_generalized_negative_binomial_like name args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_shuffle(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_shuffle ::
-         forall args . Fullfilled "_shuffle(symbol)" args =>
-           String -> ArgsHMap "_shuffle(symbol)" args -> IO SymbolHandle
-_shuffle name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_shuffle"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Custom(symbol)" =
-     '[ '("op_type", AttrOpt String), '("data", AttrOpt [SymbolHandle])]
-
-_Custom ::
-        forall args .
-          (Fullfilled "_Custom(symbol)" args,
-           PopKey (ArgOf "_Custom(symbol)") args "data",
-           Dump (PopResult (ArgOf "_Custom(symbol)") args "data")) =>
-          String -> ArgsHMap "_Custom(symbol)" args -> IO SymbolHandle
-_Custom name args
-  = let scalarArgs = dump (pop args #data)
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "Custom"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_Custom(symbol)" = '[]
-
-_backward_Custom ::
-                 forall args . Fullfilled "_backward_Custom(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_Custom(symbol)" args -> IO SymbolHandle
-_backward_Custom name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Custom"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_power(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_power ::
-                forall args . Fullfilled "broadcast_power(symbol)" args =>
-                  String ->
-                    ArgsHMap "broadcast_power(symbol)" args -> IO SymbolHandle
-broadcast_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_power(symbol)" =
-     '[]
-
-_backward_broadcast_power ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_power(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_broadcast_power(symbol)" args ->
-                                IO SymbolHandle
-_backward_broadcast_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_maximum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_maximum ::
-                  forall args . Fullfilled "broadcast_maximum(symbol)" args =>
-                    String ->
-                      ArgsHMap "broadcast_maximum(symbol)" args -> IO SymbolHandle
-broadcast_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_maximum(symbol)" =
-     '[]
-
-_backward_broadcast_maximum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_maximum(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_broadcast_maximum(symbol)" args ->
-                                  IO SymbolHandle
-_backward_broadcast_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_minimum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_minimum ::
-                  forall args . Fullfilled "broadcast_minimum(symbol)" args =>
-                    String ->
-                      ArgsHMap "broadcast_minimum(symbol)" args -> IO SymbolHandle
-broadcast_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_minimum(symbol)" =
-     '[]
-
-_backward_broadcast_minimum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_minimum(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_broadcast_minimum(symbol)" args ->
-                                  IO SymbolHandle
-_backward_broadcast_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_hypot(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_hypot ::
-                forall args . Fullfilled "broadcast_hypot(symbol)" args =>
-                  String ->
-                    ArgsHMap "broadcast_hypot(symbol)" args -> IO SymbolHandle
-broadcast_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_hypot(symbol)" =
-     '[]
-
-_backward_broadcast_hypot ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_hypot(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_broadcast_hypot(symbol)" args ->
-                                IO SymbolHandle
-_backward_broadcast_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_equal ::
-       forall args . Fullfilled "_equal(symbol)" args =>
-         String -> ArgsHMap "_equal(symbol)" args -> IO SymbolHandle
-_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_not_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_not_equal ::
-           forall args . Fullfilled "_not_equal(symbol)" args =>
-             String -> ArgsHMap "_not_equal(symbol)" args -> IO SymbolHandle
-_not_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_greater ::
-         forall args . Fullfilled "_greater(symbol)" args =>
-           String -> ArgsHMap "_greater(symbol)" args -> IO SymbolHandle
-_greater name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_greater_equal ::
-               forall args . Fullfilled "_greater_equal(symbol)" args =>
-                 String -> ArgsHMap "_greater_equal(symbol)" args -> IO SymbolHandle
-_greater_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_lesser ::
-        forall args . Fullfilled "_lesser(symbol)" args =>
-          String -> ArgsHMap "_lesser(symbol)" args -> IO SymbolHandle
-_lesser name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_lesser_equal ::
-              forall args . Fullfilled "_lesser_equal(symbol)" args =>
-                String -> ArgsHMap "_lesser_equal(symbol)" args -> IO SymbolHandle
-_lesser_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_and(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_logical_and ::
-             forall args . Fullfilled "_logical_and(symbol)" args =>
-               String -> ArgsHMap "_logical_and(symbol)" args -> IO SymbolHandle
-_logical_and name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_or(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_logical_or ::
-            forall args . Fullfilled "_logical_or(symbol)" args =>
-              String -> ArgsHMap "_logical_or(symbol)" args -> IO SymbolHandle
-_logical_or name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_xor(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_logical_xor ::
-             forall args . Fullfilled "_logical_xor(symbol)" args =>
-               String -> ArgsHMap "_logical_xor(symbol)" args -> IO SymbolHandle
-_logical_xor name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_power(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_power ::
-       forall args . Fullfilled "_power(symbol)" args =>
-         String -> ArgsHMap "_power(symbol)" args -> IO SymbolHandle
-_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_power(symbol)" = '[]
-
-_backward_power ::
-                forall args . Fullfilled "_backward_power(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_power(symbol)" args -> IO SymbolHandle
-_backward_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_maximum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_maximum ::
-         forall args . Fullfilled "_maximum(symbol)" args =>
-           String -> ArgsHMap "_maximum(symbol)" args -> IO SymbolHandle
-_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_maximum(symbol)" = '[]
-
-_backward_maximum ::
-                  forall args . Fullfilled "_backward_maximum(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_maximum(symbol)" args -> IO SymbolHandle
-_backward_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_minimum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_minimum ::
-         forall args . Fullfilled "_minimum(symbol)" args =>
-           String -> ArgsHMap "_minimum(symbol)" args -> IO SymbolHandle
-_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_minimum(symbol)" = '[]
-
-_backward_minimum ::
-                  forall args . Fullfilled "_backward_minimum(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_minimum(symbol)" args -> IO SymbolHandle
-_backward_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_hypot(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_hypot ::
-       forall args . Fullfilled "_hypot(symbol)" args =>
-         String -> ArgsHMap "_hypot(symbol)" args -> IO SymbolHandle
-_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_hypot(symbol)" = '[]
-
-_backward_hypot ::
-                forall args . Fullfilled "_backward_hypot(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_hypot(symbol)" args -> IO SymbolHandle
-_backward_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_square_sum(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-_square_sum ::
-            forall args . Fullfilled "_square_sum(symbol)" args =>
-              String -> ArgsHMap "_square_sum(symbol)" args -> IO SymbolHandle
-_square_sum name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_square_sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_square_sum(symbol)" = '[]
-
-_backward_square_sum ::
-                     forall args . Fullfilled "_backward_square_sum(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_square_sum(symbol)" args -> IO SymbolHandle
-_backward_square_sum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square_sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "add_n(symbol)" =
-     '[ '("args", AttrOpt [SymbolHandle])]
-
-add_n ::
-      forall args . Fullfilled "add_n(symbol)" args =>
-        String -> ArgsHMap "add_n(symbol)" args -> IO SymbolHandle
-add_n name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "add_n"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_zeros_without_dtype(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype", AttrOpt Int)]
-
-_zeros_without_dtype ::
-                     forall args . Fullfilled "_zeros_without_dtype(symbol)" args =>
-                       String ->
-                         ArgsHMap "_zeros_without_dtype(symbol)" args -> IO SymbolHandle
-_zeros_without_dtype name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros_without_dtype"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_zeros(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_zeros ::
-       forall args . Fullfilled "_zeros(symbol)" args =>
-         String -> ArgsHMap "_zeros(symbol)" args -> IO SymbolHandle
-_zeros name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_eye(symbol)" =
-     '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_eye ::
-     forall args . Fullfilled "_eye(symbol)" args =>
-       String -> ArgsHMap "_eye(symbol)" args -> IO SymbolHandle
-_eye name args
-  = let scalarArgs
-          = catMaybes
-              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),
-               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_eye"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_ones(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_ones ::
-      forall args . Fullfilled "_ones(symbol)" args =>
-        String -> ArgsHMap "_ones(symbol)" args -> IO SymbolHandle
-_ones name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ones"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_full(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("value", AttrReq Double)]
-
-_full ::
-      forall args . Fullfilled "_full(symbol)" args =>
-        String -> ArgsHMap "_full(symbol)" args -> IO SymbolHandle
-_full name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_full"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_arange(symbol)" =
-     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),
-        '("step", AttrOpt Double), '("repeat", AttrOpt Int),
-        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_arange ::
-        forall args . Fullfilled "_arange(symbol)" args =>
-          String -> ArgsHMap "_arange(symbol)" args -> IO SymbolHandle
-_arange name args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("infer_range",) . showValue <$>
-                 (args !? #infer_range :: Maybe Bool),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_arange"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "zeros_like(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-zeros_like ::
-           forall args . Fullfilled "zeros_like(symbol)" args =>
-             String -> ArgsHMap "zeros_like(symbol)" args -> IO SymbolHandle
-zeros_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "zeros_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ones_like(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-ones_like ::
-          forall args . Fullfilled "ones_like(symbol)" args =>
-            String -> ArgsHMap "ones_like(symbol)" args -> IO SymbolHandle
-ones_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ones_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_add(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_add ::
-              forall args . Fullfilled "broadcast_add(symbol)" args =>
-                String -> ArgsHMap "broadcast_add(symbol)" args -> IO SymbolHandle
-broadcast_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_add(symbol)" = '[]
-
-_backward_broadcast_add ::
-                        forall args . Fullfilled "_backward_broadcast_add(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_add(symbol)" args -> IO SymbolHandle
-_backward_broadcast_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_sub(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_sub ::
-              forall args . Fullfilled "broadcast_sub(symbol)" args =>
-                String -> ArgsHMap "broadcast_sub(symbol)" args -> IO SymbolHandle
-broadcast_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_sub(symbol)" = '[]
-
-_backward_broadcast_sub ::
-                        forall args . Fullfilled "_backward_broadcast_sub(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_sub(symbol)" args -> IO SymbolHandle
-_backward_broadcast_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_mul(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_mul ::
-              forall args . Fullfilled "broadcast_mul(symbol)" args =>
-                String -> ArgsHMap "broadcast_mul(symbol)" args -> IO SymbolHandle
-broadcast_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_mul(symbol)" = '[]
-
-_backward_broadcast_mul ::
-                        forall args . Fullfilled "_backward_broadcast_mul(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_mul(symbol)" args -> IO SymbolHandle
-_backward_broadcast_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_div(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_div ::
-              forall args . Fullfilled "broadcast_div(symbol)" args =>
-                String -> ArgsHMap "broadcast_div(symbol)" args -> IO SymbolHandle
-broadcast_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_div(symbol)" = '[]
-
-_backward_broadcast_div ::
-                        forall args . Fullfilled "_backward_broadcast_div(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_div(symbol)" args -> IO SymbolHandle
-_backward_broadcast_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_mod(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_mod ::
-              forall args . Fullfilled "broadcast_mod(symbol)" args =>
-                String -> ArgsHMap "broadcast_mod(symbol)" args -> IO SymbolHandle
-broadcast_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_mod(symbol)" = '[]
-
-_backward_broadcast_mod ::
-                        forall args . Fullfilled "_backward_broadcast_mod(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_mod(symbol)" args -> IO SymbolHandle
-_backward_broadcast_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_gemm(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),
-        '("axis", AttrOpt Int), '("_A", AttrOpt SymbolHandle),
-        '("_B", AttrOpt SymbolHandle), '("_C", AttrOpt SymbolHandle)]
-
-_linalg_gemm ::
-             forall args . Fullfilled "_linalg_gemm(symbol)" args =>
-               String -> ArgsHMap "_linalg_gemm(symbol)" args -> IO SymbolHandle
-_linalg_gemm name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle),
-               ("_C",) <$> (args !? #_C :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_gemm(symbol)" = '[]
-
-_backward_linalg_gemm ::
-                      forall args . Fullfilled "_backward_linalg_gemm(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_gemm(symbol)" args -> IO SymbolHandle
-_backward_linalg_gemm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_gemm2(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("axis", AttrOpt Int),
-        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)]
-
-_linalg_gemm2 ::
-              forall args . Fullfilled "_linalg_gemm2(symbol)" args =>
-                String -> ArgsHMap "_linalg_gemm2(symbol)" args -> IO SymbolHandle
-_linalg_gemm2 name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_gemm2(symbol)" = '[]
-
-_backward_linalg_gemm2 ::
-                       forall args . Fullfilled "_backward_linalg_gemm2(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_gemm2(symbol)" args -> IO SymbolHandle
-_backward_linalg_gemm2 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_potrf(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_potrf ::
-              forall args . Fullfilled "_linalg_potrf(symbol)" args =>
-                String -> ArgsHMap "_linalg_potrf(symbol)" args -> IO SymbolHandle
-_linalg_potrf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potrf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_potrf(symbol)" = '[]
-
-_backward_linalg_potrf ::
-                       forall args . Fullfilled "_backward_linalg_potrf(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_potrf(symbol)" args -> IO SymbolHandle
-_backward_linalg_potrf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potrf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_potri(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_potri ::
-              forall args . Fullfilled "_linalg_potri(symbol)" args =>
-                String -> ArgsHMap "_linalg_potri(symbol)" args -> IO SymbolHandle
-_linalg_potri name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potri"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_potri(symbol)" = '[]
-
-_backward_linalg_potri ::
-                       forall args . Fullfilled "_backward_linalg_potri(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_potri(symbol)" args -> IO SymbolHandle
-_backward_linalg_potri name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potri"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_trmm(symbol)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)]
-
-_linalg_trmm ::
-             forall args . Fullfilled "_linalg_trmm(symbol)" args =>
-               String -> ArgsHMap "_linalg_trmm(symbol)" args -> IO SymbolHandle
-_linalg_trmm name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trmm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_trmm(symbol)" = '[]
-
-_backward_linalg_trmm ::
-                      forall args . Fullfilled "_backward_linalg_trmm(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_trmm(symbol)" args -> IO SymbolHandle
-_backward_linalg_trmm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trmm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_trsm(symbol)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)]
-
-_linalg_trsm ::
-             forall args . Fullfilled "_linalg_trsm(symbol)" args =>
-               String -> ArgsHMap "_linalg_trsm(symbol)" args -> IO SymbolHandle
-_linalg_trsm name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trsm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_trsm(symbol)" = '[]
-
-_backward_linalg_trsm ::
-                      forall args . Fullfilled "_backward_linalg_trsm(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_trsm(symbol)" args -> IO SymbolHandle
-_backward_linalg_trsm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trsm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_sumlogdiag(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_sumlogdiag ::
-                   forall args . Fullfilled "_linalg_sumlogdiag(symbol)" args =>
-                     String ->
-                       ArgsHMap "_linalg_sumlogdiag(symbol)" args -> IO SymbolHandle
-_linalg_sumlogdiag name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_sumlogdiag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_sumlogdiag(symbol)" =
-     '[]
-
-_backward_linalg_sumlogdiag ::
-                            forall args .
-                              Fullfilled "_backward_linalg_sumlogdiag(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_linalg_sumlogdiag(symbol)" args ->
-                                  IO SymbolHandle
-_backward_linalg_sumlogdiag name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_syrk(symbol)" =
-     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt SymbolHandle)]
-
-_linalg_syrk ::
-             forall args . Fullfilled "_linalg_syrk(symbol)" args =>
-               String -> ArgsHMap "_linalg_syrk(symbol)" args -> IO SymbolHandle
-_linalg_syrk name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syrk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_syrk(symbol)" = '[]
-
-_backward_linalg_syrk ::
-                      forall args . Fullfilled "_backward_linalg_syrk(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_syrk(symbol)" args -> IO SymbolHandle
-_backward_linalg_syrk name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syrk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_gelqf(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_gelqf ::
-              forall args . Fullfilled "_linalg_gelqf(symbol)" args =>
-                String -> ArgsHMap "_linalg_gelqf(symbol)" args -> IO SymbolHandle
-_linalg_gelqf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gelqf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_gelqf(symbol)" = '[]
-
-_backward_linalg_gelqf ::
-                       forall args . Fullfilled "_backward_linalg_gelqf(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_gelqf(symbol)" args -> IO SymbolHandle
-_backward_linalg_gelqf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gelqf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_syevd(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_syevd ::
-              forall args . Fullfilled "_linalg_syevd(symbol)" args =>
-                String -> ArgsHMap "_linalg_syevd(symbol)" args -> IO SymbolHandle
-_linalg_syevd name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syevd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_syevd(symbol)" = '[]
-
-_backward_linalg_syevd ::
-                       forall args . Fullfilled "_backward_linalg_syevd(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_syevd(symbol)" args -> IO SymbolHandle
-_backward_linalg_syevd name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syevd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_histogram(symbol)" =
-     '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle), '("bins", AttrOpt SymbolHandle)]
-
-_histogram ::
-           forall args . Fullfilled "_histogram(symbol)" args =>
-             String -> ArgsHMap "_histogram(symbol)" args -> IO SymbolHandle
-_histogram name args
-  = let scalarArgs
-          = catMaybes
-              [("bin_cnt",) . showValue <$>
-                 (args !? #bin_cnt :: Maybe (Maybe Int)),
-               ("range",) . showValue <$> (args !? #range :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("bins",) <$> (args !? #bins :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_histogram"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cast_storage(symbol)" =
-     '[ '("stype",
-          AttrReq (EnumType '["csr", "default", "row_sparse"])),
-        '("data", AttrOpt SymbolHandle)]
-
-cast_storage ::
-             forall args . Fullfilled "cast_storage(symbol)" args =>
-               String -> ArgsHMap "cast_storage(symbol)" args -> IO SymbolHandle
-cast_storage name args
-  = let scalarArgs
-          = catMaybes
-              [("stype",) . showValue <$>
-                 (args !? #stype ::
-                    Maybe (EnumType '["csr", "default", "row_sparse"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cast_storage"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_equal_scalar ::
-              forall args . Fullfilled "_equal_scalar(symbol)" args =>
-                String -> ArgsHMap "_equal_scalar(symbol)" args -> IO SymbolHandle
-_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_not_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_not_equal_scalar ::
-                  forall args . Fullfilled "_not_equal_scalar(symbol)" args =>
-                    String ->
-                      ArgsHMap "_not_equal_scalar(symbol)" args -> IO SymbolHandle
-_not_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_greater_scalar ::
-                forall args . Fullfilled "_greater_scalar(symbol)" args =>
-                  String ->
-                    ArgsHMap "_greater_scalar(symbol)" args -> IO SymbolHandle
-_greater_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_greater_equal_scalar ::
-                      forall args . Fullfilled "_greater_equal_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_greater_equal_scalar(symbol)" args -> IO SymbolHandle
-_greater_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_lesser_scalar ::
-               forall args . Fullfilled "_lesser_scalar(symbol)" args =>
-                 String -> ArgsHMap "_lesser_scalar(symbol)" args -> IO SymbolHandle
-_lesser_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_lesser_equal_scalar ::
-                     forall args . Fullfilled "_lesser_equal_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_lesser_equal_scalar(symbol)" args -> IO SymbolHandle
-_lesser_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_and_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_logical_and_scalar ::
-                    forall args . Fullfilled "_logical_and_scalar(symbol)" args =>
-                      String ->
-                        ArgsHMap "_logical_and_scalar(symbol)" args -> IO SymbolHandle
-_logical_and_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_or_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_logical_or_scalar ::
-                   forall args . Fullfilled "_logical_or_scalar(symbol)" args =>
-                     String ->
-                       ArgsHMap "_logical_or_scalar(symbol)" args -> IO SymbolHandle
-_logical_or_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_xor_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_logical_xor_scalar ::
-                    forall args . Fullfilled "_logical_xor_scalar(symbol)" args =>
-                      String ->
-                        ArgsHMap "_logical_xor_scalar(symbol)" args -> IO SymbolHandle
-_logical_xor_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "relu(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-relu ::
-     forall args . Fullfilled "relu(symbol)" args =>
-       String -> ArgsHMap "relu(symbol)" args -> IO SymbolHandle
-relu name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "relu"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_relu(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_relu ::
-               forall args . Fullfilled "_backward_relu(symbol)" args =>
-                 String -> ArgsHMap "_backward_relu(symbol)" args -> IO SymbolHandle
-_backward_relu name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_relu"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sigmoid(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sigmoid ::
-        forall args . Fullfilled "sigmoid(symbol)" args =>
-          String -> ArgsHMap "sigmoid(symbol)" args -> IO SymbolHandle
-sigmoid name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sigmoid"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sigmoid(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sigmoid ::
-                  forall args . Fullfilled "_backward_sigmoid(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_sigmoid(symbol)" args -> IO SymbolHandle
-_backward_sigmoid name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sigmoid"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "hard_sigmoid(symbol)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-hard_sigmoid ::
-             forall args . Fullfilled "hard_sigmoid(symbol)" args =>
-               String -> ArgsHMap "hard_sigmoid(symbol)" args -> IO SymbolHandle
-hard_sigmoid name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "hard_sigmoid"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_hard_sigmoid(symbol)" = '[]
-
-_backward_hard_sigmoid ::
-                       forall args . Fullfilled "_backward_hard_sigmoid(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_hard_sigmoid(symbol)" args -> IO SymbolHandle
-_backward_hard_sigmoid name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hard_sigmoid"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "softsign(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-softsign ::
-         forall args . Fullfilled "softsign(symbol)" args =>
-           String -> ArgsHMap "softsign(symbol)" args -> IO SymbolHandle
-softsign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softsign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_softsign(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_softsign ::
-                   forall args . Fullfilled "_backward_softsign(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_softsign(symbol)" args -> IO SymbolHandle
-_backward_softsign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softsign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_copy(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_copy ::
-      forall args . Fullfilled "_copy(symbol)" args =>
-        String -> ArgsHMap "_copy(symbol)" args -> IO SymbolHandle
-_copy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_copy(symbol)" = '[]
-
-_backward_copy ::
-               forall args . Fullfilled "_backward_copy(symbol)" args =>
-                 String -> ArgsHMap "_backward_copy(symbol)" args -> IO SymbolHandle
-_backward_copy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_copy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BlockGrad(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_BlockGrad ::
-           forall args . Fullfilled "_BlockGrad(symbol)" args =>
-             String -> ArgsHMap "_BlockGrad(symbol)" args -> IO SymbolHandle
-_BlockGrad name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BlockGrad"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "make_loss(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-make_loss ::
-          forall args . Fullfilled "make_loss(symbol)" args =>
-            String -> ArgsHMap "make_loss(symbol)" args -> IO SymbolHandle
-make_loss name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "make_loss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_identity_with_attr_like_rhs(symbol)"
-     =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_identity_with_attr_like_rhs ::
-                             forall args .
-                               Fullfilled "_identity_with_attr_like_rhs(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_identity_with_attr_like_rhs(symbol)" args ->
-                                   IO SymbolHandle
-_identity_with_attr_like_rhs name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "reshape_like(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-reshape_like ::
-             forall args . Fullfilled "reshape_like(symbol)" args =>
-               String -> ArgsHMap "reshape_like(symbol)" args -> IO SymbolHandle
-reshape_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reshape_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "shape_array(symbol)" =
-     '[ '("lhs_begin", AttrOpt (Maybe Int)),
-        '("lhs_end", AttrOpt (Maybe Int)),
-        '("rhs_begin", AttrOpt (Maybe Int)),
-        '("rhs_end", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)]
-
-shape_array ::
-            forall args . Fullfilled "shape_array(symbol)" args =>
-              String -> ArgsHMap "shape_array(symbol)" args -> IO SymbolHandle
-shape_array name args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_begin",) . showValue <$>
-                 (args !? #lhs_begin :: Maybe (Maybe Int)),
-               ("lhs_end",) . showValue <$>
-                 (args !? #lhs_end :: Maybe (Maybe Int)),
-               ("rhs_begin",) . showValue <$>
-                 (args !? #rhs_begin :: Maybe (Maybe Int)),
-               ("rhs_end",) . showValue <$>
-                 (args !? #rhs_end :: Maybe (Maybe Int))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "shape_array"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "size_array(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-size_array ::
-           forall args . Fullfilled "size_array(symbol)" args =>
-             String -> ArgsHMap "size_array(symbol)" args -> IO SymbolHandle
-size_array name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "size_array"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Cast(symbol)" =
-     '[ '("dtype",
-          AttrReq
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_Cast ::
-      forall args . Fullfilled "_Cast(symbol)" args =>
-        String -> ArgsHMap "_Cast(symbol)" args -> IO SymbolHandle
-_Cast name args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Cast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cast(symbol)" = '[]
-
-_backward_cast ::
-               forall args . Fullfilled "_backward_cast(symbol)" args =>
-                 String -> ArgsHMap "_backward_cast(symbol)" args -> IO SymbolHandle
-_backward_cast name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "negative(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-negative ::
-         forall args . Fullfilled "negative(symbol)" args =>
-           String -> ArgsHMap "negative(symbol)" args -> IO SymbolHandle
-negative name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "negative"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "reciprocal(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-reciprocal ::
-           forall args . Fullfilled "reciprocal(symbol)" args =>
-             String -> ArgsHMap "reciprocal(symbol)" args -> IO SymbolHandle
-reciprocal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reciprocal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_reciprocal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_reciprocal ::
-                     forall args . Fullfilled "_backward_reciprocal(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_reciprocal(symbol)" args -> IO SymbolHandle
-_backward_reciprocal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reciprocal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "abs(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-abs ::
-    forall args . Fullfilled "abs(symbol)" args =>
-      String -> ArgsHMap "abs(symbol)" args -> IO SymbolHandle
-abs name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "abs"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_abs(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_abs ::
-              forall args . Fullfilled "_backward_abs(symbol)" args =>
-                String -> ArgsHMap "_backward_abs(symbol)" args -> IO SymbolHandle
-_backward_abs name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_abs"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sign(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sign ::
-     forall args . Fullfilled "sign(symbol)" args =>
-       String -> ArgsHMap "sign(symbol)" args -> IO SymbolHandle
-sign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sign(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sign ::
-               forall args . Fullfilled "_backward_sign(symbol)" args =>
-                 String -> ArgsHMap "_backward_sign(symbol)" args -> IO SymbolHandle
-_backward_sign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "round(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-round ::
-      forall args . Fullfilled "round(symbol)" args =>
-        String -> ArgsHMap "round(symbol)" args -> IO SymbolHandle
-round name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "round"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rint(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-rint ::
-     forall args . Fullfilled "rint(symbol)" args =>
-       String -> ArgsHMap "rint(symbol)" args -> IO SymbolHandle
-rint name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rint"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ceil(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-ceil ::
-     forall args . Fullfilled "ceil(symbol)" args =>
-       String -> ArgsHMap "ceil(symbol)" args -> IO SymbolHandle
-ceil name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ceil"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "floor(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-floor ::
-      forall args . Fullfilled "floor(symbol)" args =>
-        String -> ArgsHMap "floor(symbol)" args -> IO SymbolHandle
-floor name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "floor"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "trunc(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-trunc ::
-      forall args . Fullfilled "trunc(symbol)" args =>
-        String -> ArgsHMap "trunc(symbol)" args -> IO SymbolHandle
-trunc name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "trunc"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "fix(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-fix ::
-    forall args . Fullfilled "fix(symbol)" args =>
-      String -> ArgsHMap "fix(symbol)" args -> IO SymbolHandle
-fix name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fix"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "square(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-square ::
-       forall args . Fullfilled "square(symbol)" args =>
-         String -> ArgsHMap "square(symbol)" args -> IO SymbolHandle
-square name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "square"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_square(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_square ::
-                 forall args . Fullfilled "_backward_square(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_square(symbol)" args -> IO SymbolHandle
-_backward_square name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sqrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sqrt ::
-     forall args . Fullfilled "sqrt(symbol)" args =>
-       String -> ArgsHMap "sqrt(symbol)" args -> IO SymbolHandle
-sqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sqrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sqrt ::
-               forall args . Fullfilled "_backward_sqrt(symbol)" args =>
-                 String -> ArgsHMap "_backward_sqrt(symbol)" args -> IO SymbolHandle
-_backward_sqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rsqrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-rsqrt ::
-      forall args . Fullfilled "rsqrt(symbol)" args =>
-        String -> ArgsHMap "rsqrt(symbol)" args -> IO SymbolHandle
-rsqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rsqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rsqrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rsqrt ::
-                forall args . Fullfilled "_backward_rsqrt(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_rsqrt(symbol)" args -> IO SymbolHandle
-_backward_rsqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rsqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cbrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-cbrt ::
-     forall args . Fullfilled "cbrt(symbol)" args =>
-       String -> ArgsHMap "cbrt(symbol)" args -> IO SymbolHandle
-cbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cbrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_cbrt ::
-               forall args . Fullfilled "_backward_cbrt(symbol)" args =>
-                 String -> ArgsHMap "_backward_cbrt(symbol)" args -> IO SymbolHandle
-_backward_cbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "erf(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-erf ::
-    forall args . Fullfilled "erf(symbol)" args =>
-      String -> ArgsHMap "erf(symbol)" args -> IO SymbolHandle
-erf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "erf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_erf(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_erf ::
-              forall args . Fullfilled "_backward_erf(symbol)" args =>
-                String -> ArgsHMap "_backward_erf(symbol)" args -> IO SymbolHandle
-_backward_erf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_erf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rcbrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-rcbrt ::
-      forall args . Fullfilled "rcbrt(symbol)" args =>
-        String -> ArgsHMap "rcbrt(symbol)" args -> IO SymbolHandle
-rcbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rcbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rcbrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rcbrt ::
-                forall args . Fullfilled "_backward_rcbrt(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_rcbrt(symbol)" args -> IO SymbolHandle
-_backward_rcbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rcbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "exp(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-exp ::
-    forall args . Fullfilled "exp(symbol)" args =>
-      String -> ArgsHMap "exp(symbol)" args -> IO SymbolHandle
-exp name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "exp"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log ::
-    forall args . Fullfilled "log(symbol)" args =>
-      String -> ArgsHMap "log(symbol)" args -> IO SymbolHandle
-log name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log10(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log10 ::
-      forall args . Fullfilled "log10(symbol)" args =>
-        String -> ArgsHMap "log10(symbol)" args -> IO SymbolHandle
-log10 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log10"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log2(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log2 ::
-     forall args . Fullfilled "log2(symbol)" args =>
-       String -> ArgsHMap "log2(symbol)" args -> IO SymbolHandle
-log2 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log ::
-              forall args . Fullfilled "_backward_log(symbol)" args =>
-                String -> ArgsHMap "_backward_log(symbol)" args -> IO SymbolHandle
-_backward_log name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log10(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log10 ::
-                forall args . Fullfilled "_backward_log10(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_log10(symbol)" args -> IO SymbolHandle
-_backward_log10 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log10"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log2(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log2 ::
-               forall args . Fullfilled "_backward_log2(symbol)" args =>
-                 String -> ArgsHMap "_backward_log2(symbol)" args -> IO SymbolHandle
-_backward_log2 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log1p(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log1p ::
-      forall args . Fullfilled "log1p(symbol)" args =>
-        String -> ArgsHMap "log1p(symbol)" args -> IO SymbolHandle
-log1p name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log1p"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log1p(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log1p ::
-                forall args . Fullfilled "_backward_log1p(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_log1p(symbol)" args -> IO SymbolHandle
-_backward_log1p name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log1p"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "expm1(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-expm1 ::
-      forall args . Fullfilled "expm1(symbol)" args =>
-        String -> ArgsHMap "expm1(symbol)" args -> IO SymbolHandle
-expm1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expm1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_expm1(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_expm1 ::
-                forall args . Fullfilled "_backward_expm1(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_expm1(symbol)" args -> IO SymbolHandle
-_backward_expm1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_expm1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "gamma(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-gamma ::
-      forall args . Fullfilled "gamma(symbol)" args =>
-        String -> ArgsHMap "gamma(symbol)" args -> IO SymbolHandle
-gamma name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_gamma(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_gamma ::
-                forall args . Fullfilled "_backward_gamma(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_gamma(symbol)" args -> IO SymbolHandle
-_backward_gamma name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "gammaln(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-gammaln ::
-        forall args . Fullfilled "gammaln(symbol)" args =>
-          String -> ArgsHMap "gammaln(symbol)" args -> IO SymbolHandle
-gammaln name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gammaln"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_gammaln(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_gammaln ::
-                  forall args . Fullfilled "_backward_gammaln(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_gammaln(symbol)" args -> IO SymbolHandle
-_backward_gammaln name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gammaln"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "logical_not(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-logical_not ::
-            forall args . Fullfilled "logical_not(symbol)" args =>
-              String -> ArgsHMap "logical_not(symbol)" args -> IO SymbolHandle
-logical_not name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "logical_not"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sum(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-sum ::
-    forall args . Fullfilled "sum(symbol)" args =>
-      String -> ArgsHMap "sum(symbol)" args -> IO SymbolHandle
-sum name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sum(symbol)" = '[]
-
-_backward_sum ::
-              forall args . Fullfilled "_backward_sum(symbol)" args =>
-                String -> ArgsHMap "_backward_sum(symbol)" args -> IO SymbolHandle
-_backward_sum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "mean(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-mean ::
-     forall args . Fullfilled "mean(symbol)" args =>
-       String -> ArgsHMap "mean(symbol)" args -> IO SymbolHandle
-mean name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mean"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mean(symbol)" = '[]
-
-_backward_mean ::
-               forall args . Fullfilled "_backward_mean(symbol)" args =>
-                 String -> ArgsHMap "_backward_mean(symbol)" args -> IO SymbolHandle
-_backward_mean name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mean"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "prod(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-prod ::
-     forall args . Fullfilled "prod(symbol)" args =>
-       String -> ArgsHMap "prod(symbol)" args -> IO SymbolHandle
-prod name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "prod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_prod(symbol)" = '[]
-
-_backward_prod ::
-               forall args . Fullfilled "_backward_prod(symbol)" args =>
-                 String -> ArgsHMap "_backward_prod(symbol)" args -> IO SymbolHandle
-_backward_prod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_prod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "nansum(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-nansum ::
-       forall args . Fullfilled "nansum(symbol)" args =>
-         String -> ArgsHMap "nansum(symbol)" args -> IO SymbolHandle
-nansum name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nansum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_nansum(symbol)" = '[]
-
-_backward_nansum ::
-                 forall args . Fullfilled "_backward_nansum(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_nansum(symbol)" args -> IO SymbolHandle
-_backward_nansum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nansum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "nanprod(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-nanprod ::
-        forall args . Fullfilled "nanprod(symbol)" args =>
-          String -> ArgsHMap "nanprod(symbol)" args -> IO SymbolHandle
-nanprod name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nanprod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_nanprod(symbol)" = '[]
-
-_backward_nanprod ::
-                  forall args . Fullfilled "_backward_nanprod(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_nanprod(symbol)" args -> IO SymbolHandle
-_backward_nanprod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nanprod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "max(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-max ::
-    forall args . Fullfilled "max(symbol)" args =>
-      String -> ArgsHMap "max(symbol)" args -> IO SymbolHandle
-max name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "max"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_max(symbol)" = '[]
-
-_backward_max ::
-              forall args . Fullfilled "_backward_max(symbol)" args =>
-                String -> ArgsHMap "_backward_max(symbol)" args -> IO SymbolHandle
-_backward_max name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_max"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "min(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-min ::
-    forall args . Fullfilled "min(symbol)" args =>
-      String -> ArgsHMap "min(symbol)" args -> IO SymbolHandle
-min name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "min"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_min(symbol)" = '[]
-
-_backward_min ::
-              forall args . Fullfilled "_backward_min(symbol)" args =>
-                String -> ArgsHMap "_backward_min(symbol)" args -> IO SymbolHandle
-_backward_min name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_min"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_axis(symbol)" =
-     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-broadcast_axis ::
-               forall args . Fullfilled "broadcast_axis(symbol)" args =>
-                 String -> ArgsHMap "broadcast_axis(symbol)" args -> IO SymbolHandle
-broadcast_axis name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_axis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_to(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-broadcast_to ::
-             forall args . Fullfilled "broadcast_to(symbol)" args =>
-               String -> ArgsHMap "broadcast_to(symbol)" args -> IO SymbolHandle
-broadcast_to name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_to"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_broadcast_backward(symbol)" = '[]
-
-_broadcast_backward ::
-                    forall args . Fullfilled "_broadcast_backward(symbol)" args =>
-                      String ->
-                        ArgsHMap "_broadcast_backward(symbol)" args -> IO SymbolHandle
-_broadcast_backward name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_broadcast_backward"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_like(symbol)" =
-     '[ '("lhs_axes", AttrOpt (Maybe [Int])),
-        '("rhs_axes", AttrOpt (Maybe [Int])),
-        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_like ::
-               forall args . Fullfilled "broadcast_like(symbol)" args =>
-                 String -> ArgsHMap "broadcast_like(symbol)" args -> IO SymbolHandle
-broadcast_like name args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_axes",) . showValue <$>
-                 (args !? #lhs_axes :: Maybe (Maybe [Int])),
-               ("rhs_axes",) . showValue <$>
-                 (args !? #rhs_axes :: Maybe (Maybe [Int]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "norm(symbol)" =
-     '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])),
-        '("keepdims", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-norm ::
-     forall args . Fullfilled "norm(symbol)" args =>
-       String -> ArgsHMap "norm(symbol)" args -> IO SymbolHandle
-norm name args
-  = let scalarArgs
-          = catMaybes
-              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "norm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_norm(symbol)" = '[]
-
-_backward_norm ::
-               forall args . Fullfilled "_backward_norm(symbol)" args =>
-                 String -> ArgsHMap "_backward_norm(symbol)" args -> IO SymbolHandle
-_backward_norm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_norm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_add(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_add ::
-             forall args . Fullfilled "elemwise_add(symbol)" args =>
-               String -> ArgsHMap "elemwise_add(symbol)" args -> IO SymbolHandle
-elemwise_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_grad_add(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_grad_add ::
-          forall args . Fullfilled "_grad_add(symbol)" args =>
-            String -> ArgsHMap "_grad_add(symbol)" args -> IO SymbolHandle
-_grad_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_grad_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_add(symbol)" = '[]
-
-_backward_add ::
-              forall args . Fullfilled "_backward_add(symbol)" args =>
-                String -> ArgsHMap "_backward_add(symbol)" args -> IO SymbolHandle
-_backward_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_sub(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_sub ::
-             forall args . Fullfilled "elemwise_sub(symbol)" args =>
-               String -> ArgsHMap "elemwise_sub(symbol)" args -> IO SymbolHandle
-elemwise_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sub(symbol)" = '[]
-
-_backward_sub ::
-              forall args . Fullfilled "_backward_sub(symbol)" args =>
-                String -> ArgsHMap "_backward_sub(symbol)" args -> IO SymbolHandle
-_backward_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_mul(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_mul ::
-             forall args . Fullfilled "elemwise_mul(symbol)" args =>
-               String -> ArgsHMap "elemwise_mul(symbol)" args -> IO SymbolHandle
-elemwise_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mul(symbol)" = '[]
-
-_backward_mul ::
-              forall args . Fullfilled "_backward_mul(symbol)" args =>
-                String -> ArgsHMap "_backward_mul(symbol)" args -> IO SymbolHandle
-_backward_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_div(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_div ::
-             forall args . Fullfilled "elemwise_div(symbol)" args =>
-               String -> ArgsHMap "elemwise_div(symbol)" args -> IO SymbolHandle
-elemwise_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_div(symbol)" = '[]
-
-_backward_div ::
-              forall args . Fullfilled "_backward_div(symbol)" args =>
-                String -> ArgsHMap "_backward_div(symbol)" args -> IO SymbolHandle
-_backward_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_mod(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_mod ::
-     forall args . Fullfilled "_mod(symbol)" args =>
-       String -> ArgsHMap "_mod(symbol)" args -> IO SymbolHandle
-_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mod(symbol)" = '[]
-
-_backward_mod ::
-              forall args . Fullfilled "_backward_mod(symbol)" args =>
-                String -> ArgsHMap "_backward_mod(symbol)" args -> IO SymbolHandle
-_backward_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_elemwise_div(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_scatter_elemwise_div ::
-                      forall args . Fullfilled "_scatter_elemwise_div(symbol)" args =>
-                        String ->
-                          ArgsHMap "_scatter_elemwise_div(symbol)" args -> IO SymbolHandle
-_scatter_elemwise_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_elemwise_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_plus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_scatter_plus_scalar ::
-                     forall args . Fullfilled "_scatter_plus_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_scatter_plus_scalar(symbol)" args -> IO SymbolHandle
-_scatter_plus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_plus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_minus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_scatter_minus_scalar ::
-                      forall args . Fullfilled "_scatter_minus_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_scatter_minus_scalar(symbol)" args -> IO SymbolHandle
-_scatter_minus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_minus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Embedding(symbol)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle)]
-
-_Embedding ::
-           forall args . Fullfilled "_Embedding(symbol)" args =>
-             String -> ArgsHMap "_Embedding(symbol)" args -> IO SymbolHandle
-_Embedding name args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Embedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_SparseEmbedding(symbol)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle)]
-
-_contrib_SparseEmbedding ::
-                         forall args . Fullfilled "_contrib_SparseEmbedding(symbol)" args =>
-                           String ->
-                             ArgsHMap "_contrib_SparseEmbedding(symbol)" args -> IO SymbolHandle
-_contrib_SparseEmbedding name args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SparseEmbedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Embedding(symbol)" = '[]
-
-_backward_Embedding ::
-                    forall args . Fullfilled "_backward_Embedding(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_Embedding(symbol)" args -> IO SymbolHandle
-_backward_Embedding name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Embedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SparseEmbedding(symbol)" =
-     '[]
-
-_backward_SparseEmbedding ::
-                          forall args .
-                            Fullfilled "_backward_SparseEmbedding(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_SparseEmbedding(symbol)" args ->
-                                IO SymbolHandle
-_backward_SparseEmbedding name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SparseEmbedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "take(symbol)" =
-     '[ '("axis", AttrOpt Int),
-        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),
-        '("a", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)]
-
-take ::
-     forall args . Fullfilled "take(symbol)" args =>
-       String -> ArgsHMap "take(symbol)" args -> IO SymbolHandle
-take name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "take"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_take(symbol)" = '[]
-
-_backward_take ::
-               forall args . Fullfilled "_backward_take(symbol)" args =>
-                 String -> ArgsHMap "_backward_take(symbol)" args -> IO SymbolHandle
-_backward_take name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_take"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "batch_take(symbol)" =
-     '[ '("a", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-batch_take ::
-           forall args . Fullfilled "batch_take(symbol)" args =>
-             String -> ArgsHMap "batch_take(symbol)" args -> IO SymbolHandle
-batch_take name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_take"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "one_hot(symbol)" =
-     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),
-        '("off_value", AttrOpt Double),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("indices", AttrOpt SymbolHandle)]
-
-one_hot ::
-        forall args . Fullfilled "one_hot(symbol)" args =>
-          String -> ArgsHMap "one_hot(symbol)" args -> IO SymbolHandle
-one_hot name args
-  = let scalarArgs
-          = catMaybes
-              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),
-               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),
-               ("off_value",) . showValue <$>
-                 (args !? #off_value :: Maybe Double),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "one_hot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "gather_nd(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-gather_nd ::
-          forall args . Fullfilled "gather_nd(symbol)" args =>
-            String -> ArgsHMap "gather_nd(symbol)" args -> IO SymbolHandle
-gather_nd name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gather_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "scatter_nd(symbol)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-scatter_nd ::
-           forall args . Fullfilled "scatter_nd(symbol)" args =>
-             String -> ArgsHMap "scatter_nd(symbol)" args -> IO SymbolHandle
-scatter_nd name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "scatter_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_gather_nd(symbol)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-_backward_gather_nd ::
-                    forall args . Fullfilled "_backward_gather_nd(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_gather_nd(symbol)" args -> IO SymbolHandle
-_backward_gather_nd name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gather_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_set_nd(symbol)" =
-     '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)]
-
-_scatter_set_nd ::
-                forall args . Fullfilled "_scatter_set_nd(symbol)" args =>
-                  String ->
-                    ArgsHMap "_scatter_set_nd(symbol)" args -> IO SymbolHandle
-_scatter_set_nd name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_set_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_equal ::
-                forall args . Fullfilled "broadcast_equal(symbol)" args =>
-                  String ->
-                    ArgsHMap "broadcast_equal(symbol)" args -> IO SymbolHandle
-broadcast_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_not_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_not_equal ::
-                    forall args . Fullfilled "broadcast_not_equal(symbol)" args =>
-                      String ->
-                        ArgsHMap "broadcast_not_equal(symbol)" args -> IO SymbolHandle
-broadcast_not_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_not_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_greater(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_greater ::
-                  forall args . Fullfilled "broadcast_greater(symbol)" args =>
-                    String ->
-                      ArgsHMap "broadcast_greater(symbol)" args -> IO SymbolHandle
-broadcast_greater name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_greater_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_greater_equal ::
-                        forall args . Fullfilled "broadcast_greater_equal(symbol)" args =>
-                          String ->
-                            ArgsHMap "broadcast_greater_equal(symbol)" args -> IO SymbolHandle
-broadcast_greater_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_lesser(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_lesser ::
-                 forall args . Fullfilled "broadcast_lesser(symbol)" args =>
-                   String ->
-                     ArgsHMap "broadcast_lesser(symbol)" args -> IO SymbolHandle
-broadcast_lesser name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_lesser_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_lesser_equal ::
-                       forall args . Fullfilled "broadcast_lesser_equal(symbol)" args =>
-                         String ->
-                           ArgsHMap "broadcast_lesser_equal(symbol)" args -> IO SymbolHandle
-broadcast_lesser_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_logical_and(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_logical_and ::
-                      forall args . Fullfilled "broadcast_logical_and(symbol)" args =>
-                        String ->
-                          ArgsHMap "broadcast_logical_and(symbol)" args -> IO SymbolHandle
-broadcast_logical_and name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_and"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_logical_or(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_logical_or ::
-                     forall args . Fullfilled "broadcast_logical_or(symbol)" args =>
-                       String ->
-                         ArgsHMap "broadcast_logical_or(symbol)" args -> IO SymbolHandle
-broadcast_logical_or name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_or"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_logical_xor(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_logical_xor ::
-                      forall args . Fullfilled "broadcast_logical_xor(symbol)" args =>
-                        String ->
-                          ArgsHMap "broadcast_logical_xor(symbol)" args -> IO SymbolHandle
-broadcast_logical_xor name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_xor"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_plus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_plus_scalar ::
-             forall args . Fullfilled "_plus_scalar(symbol)" args =>
-               String -> ArgsHMap "_plus_scalar(symbol)" args -> IO SymbolHandle
-_plus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_plus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_minus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_minus_scalar ::
-              forall args . Fullfilled "_minus_scalar(symbol)" args =>
-                String -> ArgsHMap "_minus_scalar(symbol)" args -> IO SymbolHandle
-_minus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rminus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rminus_scalar ::
-               forall args . Fullfilled "_rminus_scalar(symbol)" args =>
-                 String -> ArgsHMap "_rminus_scalar(symbol)" args -> IO SymbolHandle
-_rminus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rminus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_mul_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_mul_scalar ::
-            forall args . Fullfilled "_mul_scalar(symbol)" args =>
-              String -> ArgsHMap "_mul_scalar(symbol)" args -> IO SymbolHandle
-_mul_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mul_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mul_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_backward_mul_scalar ::
-                     forall args . Fullfilled "_backward_mul_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_mul_scalar(symbol)" args -> IO SymbolHandle
-_backward_mul_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_div_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_div_scalar ::
-            forall args . Fullfilled "_div_scalar(symbol)" args =>
-              String -> ArgsHMap "_div_scalar(symbol)" args -> IO SymbolHandle
-_div_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_div_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_div_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_backward_div_scalar ::
-                     forall args . Fullfilled "_backward_div_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_div_scalar(symbol)" args -> IO SymbolHandle
-_backward_div_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rdiv_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rdiv_scalar ::
-             forall args . Fullfilled "_rdiv_scalar(symbol)" args =>
-               String -> ArgsHMap "_rdiv_scalar(symbol)" args -> IO SymbolHandle
-_rdiv_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rdiv_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rdiv_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rdiv_scalar ::
-                      forall args . Fullfilled "_backward_rdiv_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_rdiv_scalar(symbol)" args -> IO SymbolHandle
-_backward_rdiv_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rdiv_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_mod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_mod_scalar ::
-            forall args . Fullfilled "_mod_scalar(symbol)" args =>
-              String -> ArgsHMap "_mod_scalar(symbol)" args -> IO SymbolHandle
-_mod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_mod_scalar ::
-                     forall args . Fullfilled "_backward_mod_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_mod_scalar(symbol)" args -> IO SymbolHandle
-_backward_mod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rmod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rmod_scalar ::
-             forall args . Fullfilled "_rmod_scalar(symbol)" args =>
-               String -> ArgsHMap "_rmod_scalar(symbol)" args -> IO SymbolHandle
-_rmod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rmod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rmod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rmod_scalar ::
-                      forall args . Fullfilled "_backward_rmod_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_rmod_scalar(symbol)" args -> IO SymbolHandle
-_backward_rmod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rmod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_ravel_multi_index(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-_ravel_multi_index ::
-                   forall args . Fullfilled "_ravel_multi_index(symbol)" args =>
-                     String ->
-                       ArgsHMap "_ravel_multi_index(symbol)" args -> IO SymbolHandle
-_ravel_multi_index name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ravel_multi_index"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_unravel_index(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-_unravel_index ::
-               forall args . Fullfilled "_unravel_index(symbol)" args =>
-                 String -> ArgsHMap "_unravel_index(symbol)" args -> IO SymbolHandle
-_unravel_index name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_unravel_index"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argmax(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-argmax ::
-       forall args . Fullfilled "argmax(symbol)" args =>
-         String -> ArgsHMap "argmax(symbol)" args -> IO SymbolHandle
-argmax name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argmin(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-argmin ::
-       forall args . Fullfilled "argmin(symbol)" args =>
-         String -> ArgsHMap "argmin(symbol)" args -> IO SymbolHandle
-argmin name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argmax_channel(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-argmax_channel ::
-               forall args . Fullfilled "argmax_channel(symbol)" args =>
-                 String -> ArgsHMap "argmax_channel(symbol)" args -> IO SymbolHandle
-argmax_channel name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax_channel"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "pick(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("mode", AttrOpt (EnumType '["clip", "wrap"])),
-        '("data", AttrOpt SymbolHandle), '("index", AttrOpt SymbolHandle)]
-
-pick ::
-     forall args . Fullfilled "pick(symbol)" args =>
-       String -> ArgsHMap "pick(symbol)" args -> IO SymbolHandle
-pick name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("index",) <$> (args !? #index :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "pick"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_pick(symbol)" = '[]
-
-_backward_pick ::
-               forall args . Fullfilled "_backward_pick(symbol)" args =>
-                 String -> ArgsHMap "_backward_pick(symbol)" args -> IO SymbolHandle
-_backward_pick name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_pick"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sparse_retain(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-_sparse_retain ::
-               forall args . Fullfilled "_sparse_retain(symbol)" args =>
-                 String -> ArgsHMap "_sparse_retain(symbol)" args -> IO SymbolHandle
-_sparse_retain name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_retain"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sparse_retain(symbol)" = '[]
-
-_backward_sparse_retain ::
-                        forall args . Fullfilled "_backward_sparse_retain(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_sparse_retain(symbol)" args -> IO SymbolHandle
-_backward_sparse_retain name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sparse_retain"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_where(symbol)" =
-     '[ '("condition", AttrOpt SymbolHandle),
-        '("x", AttrOpt SymbolHandle), '("y", AttrOpt SymbolHandle)]
-
-_where ::
-       forall args . Fullfilled "_where(symbol)" args =>
-         String -> ArgsHMap "_where(symbol)" args -> IO SymbolHandle
-_where name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("condition",) <$> (args !? #condition :: Maybe SymbolHandle),
-               ("x",) <$> (args !? #x :: Maybe SymbolHandle),
-               ("y",) <$> (args !? #y :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "where"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_where(symbol)" = '[]
-
-_backward_where ::
-                forall args . Fullfilled "_backward_where(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_where(symbol)" args -> IO SymbolHandle
-_backward_where name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_where"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "diag(symbol)" =
-     '[ '("k", AttrOpt Int), '("axis1", AttrOpt Int),
-        '("axis2", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-diag ::
-     forall args . Fullfilled "diag(symbol)" args =>
-       String -> ArgsHMap "diag(symbol)" args -> IO SymbolHandle
-diag name args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int),
-               ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "diag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_diag(symbol)" = '[]
-
-_backward_diag ::
-               forall args . Fullfilled "_backward_diag(symbol)" args =>
-                 String -> ArgsHMap "_backward_diag(symbol)" args -> IO SymbolHandle
-_backward_diag name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_diag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_maximum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_maximum_scalar ::
-                forall args . Fullfilled "_maximum_scalar(symbol)" args =>
-                  String ->
-                    ArgsHMap "_maximum_scalar(symbol)" args -> IO SymbolHandle
-_maximum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_maximum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_maximum_scalar ::
-                         forall args . Fullfilled "_backward_maximum_scalar(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_maximum_scalar(symbol)" args -> IO SymbolHandle
-_backward_maximum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_minimum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_minimum_scalar ::
-                forall args . Fullfilled "_minimum_scalar(symbol)" args =>
-                  String ->
-                    ArgsHMap "_minimum_scalar(symbol)" args -> IO SymbolHandle
-_minimum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_minimum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_minimum_scalar ::
-                         forall args . Fullfilled "_backward_minimum_scalar(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_minimum_scalar(symbol)" args -> IO SymbolHandle
-_backward_minimum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_power_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_power_scalar ::
-              forall args . Fullfilled "_power_scalar(symbol)" args =>
-                String -> ArgsHMap "_power_scalar(symbol)" args -> IO SymbolHandle
-_power_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_power_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_power_scalar ::
-                       forall args . Fullfilled "_backward_power_scalar(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_power_scalar(symbol)" args -> IO SymbolHandle
-_backward_power_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rpower_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rpower_scalar ::
-               forall args . Fullfilled "_rpower_scalar(symbol)" args =>
-                 String -> ArgsHMap "_rpower_scalar(symbol)" args -> IO SymbolHandle
-_rpower_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rpower_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rpower_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rpower_scalar ::
-                        forall args . Fullfilled "_backward_rpower_scalar(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_rpower_scalar(symbol)" args -> IO SymbolHandle
-_backward_rpower_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rpower_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_hypot_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_hypot_scalar ::
-              forall args . Fullfilled "_hypot_scalar(symbol)" args =>
-                String -> ArgsHMap "_hypot_scalar(symbol)" args -> IO SymbolHandle
-_hypot_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_hypot_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_hypot_scalar ::
-                       forall args . Fullfilled "_backward_hypot_scalar(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_hypot_scalar(symbol)" args -> IO SymbolHandle
-_backward_hypot_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "smooth_l1(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-smooth_l1 ::
-          forall args . Fullfilled "smooth_l1(symbol)" args =>
-            String -> ArgsHMap "smooth_l1(symbol)" args -> IO SymbolHandle
-smooth_l1 name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "smooth_l1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_smooth_l1(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_smooth_l1 ::
-                    forall args . Fullfilled "_backward_smooth_l1(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_smooth_l1(symbol)" args -> IO SymbolHandle
-_backward_smooth_l1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_smooth_l1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "topk(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),
-        '("ret_typ",
-          AttrOpt (EnumType '["both", "indices", "mask", "value"])),
-        '("is_ascend", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt SymbolHandle)]
-
-topk ::
-     forall args . Fullfilled "topk(symbol)" args =>
-       String -> ArgsHMap "topk(symbol)" args -> IO SymbolHandle
-topk name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ret_typ",) . showValue <$>
-                 (args !? #ret_typ ::
-                    Maybe (EnumType '["both", "indices", "mask", "value"])),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "topk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_topk(symbol)" = '[]
-
-_backward_topk ::
-               forall args . Fullfilled "_backward_topk(symbol)" args =>
-                 String -> ArgsHMap "_backward_topk(symbol)" args -> IO SymbolHandle
-_backward_topk name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_topk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sort(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-sort ::
-     forall args . Fullfilled "sort(symbol)" args =>
-       String -> ArgsHMap "sort(symbol)" args -> IO SymbolHandle
-sort name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sort"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argsort(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt SymbolHandle)]
-
-argsort ::
-        forall args . Fullfilled "argsort(symbol)" args =>
-          String -> ArgsHMap "argsort(symbol)" args -> IO SymbolHandle
-argsort name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argsort"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Reshape(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),
-        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-_Reshape ::
-         forall args . Fullfilled "_Reshape(symbol)" args =>
-           String -> ArgsHMap "_Reshape(symbol)" args -> IO SymbolHandle
-_Reshape name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("keep_highest",) . showValue <$>
-                 (args !? #keep_highest :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Reshape"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Flatten(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_Flatten ::
-         forall args . Fullfilled "_Flatten(symbol)" args =>
-           String -> ArgsHMap "_Flatten(symbol)" args -> IO SymbolHandle
-_Flatten name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Flatten"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "transpose(symbol)" =
-     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-transpose ::
-          forall args . Fullfilled "transpose(symbol)" args =>
-            String -> ArgsHMap "transpose(symbol)" args -> IO SymbolHandle
-transpose name args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "transpose"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "expand_dims(symbol)" =
-     '[ '("axis", AttrReq Int), '("data", AttrOpt SymbolHandle)]
-
-expand_dims ::
-            forall args . Fullfilled "expand_dims(symbol)" args =>
-              String -> ArgsHMap "expand_dims(symbol)" args -> IO SymbolHandle
-expand_dims name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expand_dims"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "slice(symbol)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-slice ::
-      forall args . Fullfilled "slice(symbol)" args =>
-        String -> ArgsHMap "slice(symbol)" args -> IO SymbolHandle
-slice name args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_slice(symbol)" = '[]
-
-_backward_slice ::
-                forall args . Fullfilled "_backward_slice(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_slice(symbol)" args -> IO SymbolHandle
-_backward_slice name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_slice_assign(symbol)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_slice_assign ::
-              forall args . Fullfilled "_slice_assign(symbol)" args =>
-                String -> ArgsHMap "_slice_assign(symbol)" args -> IO SymbolHandle
-_slice_assign name args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_slice_assign_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Double), '("begin", AttrReq [Int]),
-        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-_slice_assign_scalar ::
-                     forall args . Fullfilled "_slice_assign_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_slice_assign_scalar(symbol)" args -> IO SymbolHandle
-_slice_assign_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "slice_axis(symbol)" =
-     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),
-        '("end", AttrReq (Maybe Int)), '("data", AttrOpt SymbolHandle)]
-
-slice_axis ::
-           forall args . Fullfilled "slice_axis(symbol)" args =>
-             String -> ArgsHMap "slice_axis(symbol)" args -> IO SymbolHandle
-slice_axis name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),
-               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_axis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_slice_axis(symbol)" = '[]
-
-_backward_slice_axis ::
-                     forall args . Fullfilled "_backward_slice_axis(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_slice_axis(symbol)" args -> IO SymbolHandle
-_backward_slice_axis name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_axis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "slice_like(symbol)" =
-     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle),
-        '("shape_like", AttrOpt SymbolHandle)]
-
-slice_like ::
-           forall args . Fullfilled "slice_like(symbol)" args =>
-             String -> ArgsHMap "slice_like(symbol)" args -> IO SymbolHandle
-slice_like name args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("shape_like",) <$> (args !? #shape_like :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_slice_like(symbol)" = '[]
-
-_backward_slice_like ::
-                     forall args . Fullfilled "_backward_slice_like(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_slice_like(symbol)" args -> IO SymbolHandle
-_backward_slice_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "clip(symbol)" =
-     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-clip ::
-     forall args . Fullfilled "clip(symbol)" args =>
-       String -> ArgsHMap "clip(symbol)" args -> IO SymbolHandle
-clip name args
-  = let scalarArgs
-          = catMaybes
-              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),
-               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "clip"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_clip(symbol)" = '[]
-
-_backward_clip ::
-               forall args . Fullfilled "_backward_clip(symbol)" args =>
-                 String -> ArgsHMap "_backward_clip(symbol)" args -> IO SymbolHandle
-_backward_clip name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_clip"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "repeat(symbol)" =
-     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),
-        '("data", AttrOpt SymbolHandle)]
-
-repeat ::
-       forall args . Fullfilled "repeat(symbol)" args =>
-         String -> ArgsHMap "repeat(symbol)" args -> IO SymbolHandle
-repeat name args
-  = let scalarArgs
-          = catMaybes
-              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "repeat"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_repeat(symbol)" = '[]
-
-_backward_repeat ::
-                 forall args . Fullfilled "_backward_repeat(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_repeat(symbol)" args -> IO SymbolHandle
-_backward_repeat name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_repeat"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "tile(symbol)" =
-     '[ '("reps", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]
-
-tile ::
-     forall args . Fullfilled "tile(symbol)" args =>
-       String -> ArgsHMap "tile(symbol)" args -> IO SymbolHandle
-tile name args
-  = let scalarArgs
-          = catMaybes
-              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tile"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_tile(symbol)" = '[]
-
-_backward_tile ::
-               forall args . Fullfilled "_backward_tile(symbol)" args =>
-                 String -> ArgsHMap "_backward_tile(symbol)" args -> IO SymbolHandle
-_backward_tile name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tile"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "reverse(symbol)" =
-     '[ '("axis", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]
-
-reverse ::
-        forall args . Fullfilled "reverse(symbol)" args =>
-          String -> ArgsHMap "reverse(symbol)" args -> IO SymbolHandle
-reverse name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_reverse(symbol)" = '[]
-
-_backward_reverse ::
-                  forall args . Fullfilled "_backward_reverse(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_reverse(symbol)" args -> IO SymbolHandle
-_backward_reverse name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "stack(symbol)" =
-     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-stack ::
-      forall args . Fullfilled "stack(symbol)" args =>
-        String -> ArgsHMap "stack(symbol)" args -> IO SymbolHandle
-stack name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "stack"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_stack(symbol)" = '[]
-
-_backward_stack ::
-                forall args . Fullfilled "_backward_stack(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_stack(symbol)" args -> IO SymbolHandle
-_backward_stack name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_stack"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "squeeze(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])),
-        '("data", AttrOpt [SymbolHandle])]
-
-squeeze ::
-        forall args . Fullfilled "squeeze(symbol)" args =>
-          String -> ArgsHMap "squeeze(symbol)" args -> IO SymbolHandle
-squeeze name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "squeeze"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_squeeze(symbol)" = '[]
-
-_backward_squeeze ::
-                  forall args . Fullfilled "_backward_squeeze(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_squeeze(symbol)" args -> IO SymbolHandle
-_backward_squeeze name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_squeeze"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "depth_to_space(symbol)" =
-     '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)]
-
-depth_to_space ::
-               forall args . Fullfilled "depth_to_space(symbol)" args =>
-                 String -> ArgsHMap "depth_to_space(symbol)" args -> IO SymbolHandle
-depth_to_space name args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "depth_to_space"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "space_to_depth(symbol)" =
-     '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)]
-
-space_to_depth ::
-               forall args . Fullfilled "space_to_depth(symbol)" args =>
-                 String -> ArgsHMap "space_to_depth(symbol)" args -> IO SymbolHandle
-space_to_depth name args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "space_to_depth"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "dot(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),
-        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-dot ::
-    forall args . Fullfilled "dot(symbol)" args =>
-      String -> ArgsHMap "dot(symbol)" args -> IO SymbolHandle
-dot name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_dot(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-
-_backward_dot ::
-              forall args . Fullfilled "_backward_dot(symbol)" args =>
-                String -> ArgsHMap "_backward_dot(symbol)" args -> IO SymbolHandle
-_backward_dot name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "batch_dot(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),
-        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-batch_dot ::
-          forall args . Fullfilled "batch_dot(symbol)" args =>
-            String -> ArgsHMap "batch_dot(symbol)" args -> IO SymbolHandle
-batch_dot name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_batch_dot(symbol)" = '[]
-
-_backward_batch_dot ::
-                    forall args . Fullfilled "_backward_batch_dot(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_batch_dot(symbol)" args -> IO SymbolHandle
-_backward_batch_dot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_batch_dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sin(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sin ::
-    forall args . Fullfilled "sin(symbol)" args =>
-      String -> ArgsHMap "sin(symbol)" args -> IO SymbolHandle
-sin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sin(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sin ::
-              forall args . Fullfilled "_backward_sin(symbol)" args =>
-                String -> ArgsHMap "_backward_sin(symbol)" args -> IO SymbolHandle
-_backward_sin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cos(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-cos ::
-    forall args . Fullfilled "cos(symbol)" args =>
-      String -> ArgsHMap "cos(symbol)" args -> IO SymbolHandle
-cos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cos(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_cos ::
-              forall args . Fullfilled "_backward_cos(symbol)" args =>
-                String -> ArgsHMap "_backward_cos(symbol)" args -> IO SymbolHandle
-_backward_cos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "tan(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-tan ::
-    forall args . Fullfilled "tan(symbol)" args =>
-      String -> ArgsHMap "tan(symbol)" args -> IO SymbolHandle
-tan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_tan(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_tan ::
-              forall args . Fullfilled "_backward_tan(symbol)" args =>
-                String -> ArgsHMap "_backward_tan(symbol)" args -> IO SymbolHandle
-_backward_tan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arcsin(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arcsin ::
-       forall args . Fullfilled "arcsin(symbol)" args =>
-         String -> ArgsHMap "arcsin(symbol)" args -> IO SymbolHandle
-arcsin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arcsin(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arcsin ::
-                 forall args . Fullfilled "_backward_arcsin(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_arcsin(symbol)" args -> IO SymbolHandle
-_backward_arcsin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arccos(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arccos ::
-       forall args . Fullfilled "arccos(symbol)" args =>
-         String -> ArgsHMap "arccos(symbol)" args -> IO SymbolHandle
-arccos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arccos(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arccos ::
-                 forall args . Fullfilled "_backward_arccos(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_arccos(symbol)" args -> IO SymbolHandle
-_backward_arccos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arctan(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arctan ::
-       forall args . Fullfilled "arctan(symbol)" args =>
-         String -> ArgsHMap "arctan(symbol)" args -> IO SymbolHandle
-arctan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arctan(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arctan ::
-                 forall args . Fullfilled "_backward_arctan(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_arctan(symbol)" args -> IO SymbolHandle
-_backward_arctan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "degrees(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-degrees ::
-        forall args . Fullfilled "degrees(symbol)" args =>
-          String -> ArgsHMap "degrees(symbol)" args -> IO SymbolHandle
-degrees name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "degrees"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_degrees(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_degrees ::
-                  forall args . Fullfilled "_backward_degrees(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_degrees(symbol)" args -> IO SymbolHandle
-_backward_degrees name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_degrees"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "radians(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-radians ::
-        forall args . Fullfilled "radians(symbol)" args =>
-          String -> ArgsHMap "radians(symbol)" args -> IO SymbolHandle
-radians name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "radians"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_radians(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_radians ::
-                  forall args . Fullfilled "_backward_radians(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_radians(symbol)" args -> IO SymbolHandle
-_backward_radians name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_radians"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sinh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sinh ::
-     forall args . Fullfilled "sinh(symbol)" args =>
-       String -> ArgsHMap "sinh(symbol)" args -> IO SymbolHandle
-sinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sinh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sinh ::
-               forall args . Fullfilled "_backward_sinh(symbol)" args =>
-                 String -> ArgsHMap "_backward_sinh(symbol)" args -> IO SymbolHandle
-_backward_sinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cosh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-cosh ::
-     forall args . Fullfilled "cosh(symbol)" args =>
-       String -> ArgsHMap "cosh(symbol)" args -> IO SymbolHandle
-cosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cosh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_cosh ::
-               forall args . Fullfilled "_backward_cosh(symbol)" args =>
-                 String -> ArgsHMap "_backward_cosh(symbol)" args -> IO SymbolHandle
-_backward_cosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "tanh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-tanh ::
-     forall args . Fullfilled "tanh(symbol)" args =>
-       String -> ArgsHMap "tanh(symbol)" args -> IO SymbolHandle
-tanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_tanh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_tanh ::
-               forall args . Fullfilled "_backward_tanh(symbol)" args =>
-                 String -> ArgsHMap "_backward_tanh(symbol)" args -> IO SymbolHandle
-_backward_tanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arcsinh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arcsinh ::
-        forall args . Fullfilled "arcsinh(symbol)" args =>
-          String -> ArgsHMap "arcsinh(symbol)" args -> IO SymbolHandle
-arcsinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arcsinh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arcsinh ::
-                  forall args . Fullfilled "_backward_arcsinh(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_arcsinh(symbol)" args -> IO SymbolHandle
-_backward_arcsinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arccosh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arccosh ::
-        forall args . Fullfilled "arccosh(symbol)" args =>
-          String -> ArgsHMap "arccosh(symbol)" args -> IO SymbolHandle
-arccosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arccosh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arccosh ::
-                  forall args . Fullfilled "_backward_arccosh(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_arccosh(symbol)" args -> IO SymbolHandle
-_backward_arccosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arctanh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arctanh ::
-        forall args . Fullfilled "arctanh(symbol)" args =>
-          String -> ArgsHMap "arctanh(symbol)" args -> IO SymbolHandle
-arctanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arctanh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arctanh ::
-                  forall args . Fullfilled "_backward_arctanh(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_arctanh(symbol)" args -> IO SymbolHandle
-_backward_arctanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_group_adagrad_update(symbol)"
-     =
-     '[ '("lr", AttrReq Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("history", AttrOpt SymbolHandle)]
-
-_contrib_group_adagrad_update ::
-                              forall args .
-                                Fullfilled "_contrib_group_adagrad_update(symbol)" args =>
-                                String ->
-                                  ArgsHMap "_contrib_group_adagrad_update(symbol)" args ->
-                                    IO SymbolHandle
-_contrib_group_adagrad_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("history",) <$> (args !? #history :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_group_adagrad_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_getnnz(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)]
-
-_contrib_getnnz ::
-                forall args . Fullfilled "_contrib_getnnz(symbol)" args =>
-                  String ->
-                    ArgsHMap "_contrib_getnnz(symbol)" args -> IO SymbolHandle
-_contrib_getnnz name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_getnnz"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_edge_id(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle), '("u", AttrOpt SymbolHandle),
-        '("v", AttrOpt SymbolHandle)]
-
-_contrib_edge_id ::
-                 forall args . Fullfilled "_contrib_edge_id(symbol)" args =>
-                   String ->
-                     ArgsHMap "_contrib_edge_id(symbol)" args -> IO SymbolHandle
-_contrib_edge_id name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("u",) <$> (args !? #u :: Maybe SymbolHandle),
-               ("v",) <$> (args !? #v :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_edge_id"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_dgl_adjacency(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_contrib_dgl_adjacency ::
-                       forall args . Fullfilled "_contrib_dgl_adjacency(symbol)" args =>
-                         String ->
-                           ArgsHMap "_contrib_dgl_adjacency(symbol)" args -> IO SymbolHandle
-_contrib_dgl_adjacency name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dgl_adjacency"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quadratic(symbol)" =
-     '[ '("a", AttrOpt Float), '("b", AttrOpt Float),
-        '("c", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_contrib_quadratic ::
-                   forall args . Fullfilled "_contrib_quadratic(symbol)" args =>
-                     String ->
-                       ArgsHMap "_contrib_quadratic(symbol)" args -> IO SymbolHandle
-_contrib_quadratic name args
-  = let scalarArgs
-          = catMaybes
-              [("a",) . showValue <$> (args !? #a :: Maybe Float),
-               ("b",) . showValue <$> (args !? #b :: Maybe Float),
-               ("c",) . showValue <$> (args !? #c :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quadratic"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_backward_quadratic(symbol)" =
-     '[]
-
-_contrib_backward_quadratic ::
-                            forall args .
-                              Fullfilled "_contrib_backward_quadratic(symbol)" args =>
-                              String ->
-                                ArgsHMap "_contrib_backward_quadratic(symbol)" args ->
-                                  IO SymbolHandle
-_contrib_backward_quadratic name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_quadratic"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_div_sqrt_dim(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_contrib_div_sqrt_dim ::
-                      forall args . Fullfilled "_contrib_div_sqrt_dim(symbol)" args =>
-                        String ->
-                          ArgsHMap "_contrib_div_sqrt_dim(symbol)" args -> IO SymbolHandle
-_contrib_div_sqrt_dim name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "khatri_rao(symbol)" =
-     '[ '("args", AttrOpt [SymbolHandle])]
-
-khatri_rao ::
-           forall args . Fullfilled "khatri_rao(symbol)" args =>
-             String -> ArgsHMap "khatri_rao(symbol)" args -> IO SymbolHandle
-khatri_rao name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "khatri_rao"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_contrib_index_copy(symbol)" =
-     '[ '("old_tensor", AttrOpt SymbolHandle),
-        '("index_vector", AttrOpt SymbolHandle),
-        '("new_tensor", AttrOpt SymbolHandle)]
-
-_contrib_index_copy ::
-                    forall args . Fullfilled "_contrib_index_copy(symbol)" args =>
-                      String ->
-                        ArgsHMap "_contrib_index_copy(symbol)" args -> IO SymbolHandle
-_contrib_index_copy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("old_tensor",) <$> (args !? #old_tensor :: Maybe SymbolHandle),
-               ("index_vector",) <$>
-                 (args !? #index_vector :: Maybe SymbolHandle),
-               ("new_tensor",) <$> (args !? #new_tensor :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_index_copy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_backward_index_copy(symbol)"
-     = '[]
-
-_contrib_backward_index_copy ::
-                             forall args .
-                               Fullfilled "_contrib_backward_index_copy(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_contrib_backward_index_copy(symbol)" args ->
-                                   IO SymbolHandle
-_contrib_backward_index_copy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_index_copy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_ROIAlign(symbol)" =
-     '[ '("pooled_size", AttrReq [Int]),
-        '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)]
-
-_contrib_ROIAlign ::
-                  forall args . Fullfilled "_contrib_ROIAlign(symbol)" args =>
-                    String ->
-                      ArgsHMap "_contrib_ROIAlign(symbol)" args -> IO SymbolHandle
-_contrib_ROIAlign name args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("sample_ratio",) . showValue <$>
-                 (args !? #sample_ratio :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ROIAlign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_ROIAlign(symbol)" = '[]
-
-_backward_ROIAlign ::
-                   forall args . Fullfilled "_backward_ROIAlign(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_ROIAlign(symbol)" args -> IO SymbolHandle
-_backward_ROIAlign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIAlign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_box_nms(symbol)" =
-     '[ '("overlap_thresh", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),
-        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),
-        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),
-        '("in_format", AttrOpt (EnumType '["center", "corner"])),
-        '("out_format", AttrOpt (EnumType '["center", "corner"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_contrib_box_nms ::
-                 forall args . Fullfilled "_contrib_box_nms(symbol)" args =>
-                   String ->
-                     ArgsHMap "_contrib_box_nms(symbol)" args -> IO SymbolHandle
-_contrib_box_nms name args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_nms"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_contrib_box_nms(symbol)" =
-     '[ '("overlap_thresh", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),
-        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),
-        '("id_index", AttrOpt Int), '("force_suppress", AttrOpt Bool),
-        '("in_format", AttrOpt (EnumType '["center", "corner"])),
-        '("out_format", AttrOpt (EnumType '["center", "corner"]))]
-
-_backward_contrib_box_nms ::
-                          forall args .
-                            Fullfilled "_backward_contrib_box_nms(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_contrib_box_nms(symbol)" args ->
-                                IO SymbolHandle
-_backward_contrib_box_nms name args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_nms"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_box_iou(symbol)" =
-     '[ '("format", AttrOpt (EnumType '["center", "corner"])),
-        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_contrib_box_iou ::
-                 forall args . Fullfilled "_contrib_box_iou(symbol)" args =>
-                   String ->
-                     ArgsHMap "_contrib_box_iou(symbol)" args -> IO SymbolHandle
-_contrib_box_iou name args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_iou"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_contrib_box_iou(symbol)" =
-     '[ '("format", AttrOpt (EnumType '["center", "corner"]))]
-
-_backward_contrib_box_iou ::
-                          forall args .
-                            Fullfilled "_backward_contrib_box_iou(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_contrib_box_iou(symbol)" args ->
-                                IO SymbolHandle
-_backward_contrib_box_iou name args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_iou"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_bipartite_matching(symbol)" =
-     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),
-        '("topk", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-_contrib_bipartite_matching ::
-                            forall args .
-                              Fullfilled "_contrib_bipartite_matching(symbol)" args =>
-                              String ->
-                                ArgsHMap "_contrib_bipartite_matching(symbol)" args ->
-                                  IO SymbolHandle
-_contrib_bipartite_matching name args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_bipartite_matching"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_contrib_bipartite_matching(symbol)" =
-     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),
-        '("topk", AttrOpt Int)]
-
-_backward_contrib_bipartite_matching ::
-                                     forall args .
-                                       Fullfilled "_backward_contrib_bipartite_matching(symbol)"
-                                         args =>
-                                       String ->
-                                         ArgsHMap "_backward_contrib_bipartite_matching(symbol)"
-                                           args
-                                           -> IO SymbolHandle
-_backward_contrib_bipartite_matching name args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_BilinearResize2D(symbol)" =
-     '[ '("height", AttrReq Int), '("width", AttrReq Int),
-        '("data", AttrOpt SymbolHandle)]
-
-_contrib_BilinearResize2D ::
-                          forall args .
-                            Fullfilled "_contrib_BilinearResize2D(symbol)" args =>
-                            String ->
-                              ArgsHMap "_contrib_BilinearResize2D(symbol)" args ->
-                                IO SymbolHandle
-_contrib_BilinearResize2D name args
-  = let scalarArgs
-          = catMaybes
-              [("height",) . showValue <$> (args !? #height :: Maybe Int),
-               ("width",) . showValue <$> (args !? #width :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_BilinearResize2D"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_contrib_BilinearResize2D(symbol)" = '[]
-
-_backward_contrib_BilinearResize2D ::
-                                   forall args .
-                                     Fullfilled "_backward_contrib_BilinearResize2D(symbol)" args =>
-                                     String ->
-                                       ArgsHMap "_backward_contrib_BilinearResize2D(symbol)" args ->
-                                         IO SymbolHandle
-_backward_contrib_BilinearResize2D name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_boolean_mask(symbol)" =
-     '[ '("axis", AttrOpt Int), '("data", AttrOpt SymbolHandle),
-        '("index", AttrOpt SymbolHandle)]
-
-_contrib_boolean_mask ::
-                      forall args . Fullfilled "_contrib_boolean_mask(symbol)" args =>
-                        String ->
-                          ArgsHMap "_contrib_boolean_mask(symbol)" args -> IO SymbolHandle
-_contrib_boolean_mask name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("index",) <$> (args !? #index :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_boolean_mask"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_contrib_boolean_mask(symbol)" =
-     '[ '("axis", AttrOpt Int)]
-
-_backward_contrib_boolean_mask ::
-                               forall args .
-                                 Fullfilled "_backward_contrib_boolean_mask(symbol)" args =>
-                                 String ->
-                                   ArgsHMap "_backward_contrib_boolean_mask(symbol)" args ->
-                                     IO SymbolHandle
-_backward_contrib_boolean_mask name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_boolean_mask"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_SyncBatchNorm(symbol)" =
-     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int),
-        '("key", AttrOpt String), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),
-        '("moving_mean", AttrOpt SymbolHandle),
-        '("moving_var", AttrOpt SymbolHandle)]
-
-_contrib_SyncBatchNorm ::
-                       forall args . Fullfilled "_contrib_SyncBatchNorm(symbol)" args =>
-                         String ->
-                           ArgsHMap "_contrib_SyncBatchNorm(symbol)" args -> IO SymbolHandle
-_contrib_SyncBatchNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),
-               ("key",) . showValue <$> (args !? #key :: Maybe String)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_AdaptiveAvgPooling2D(symbol)"
-     =
-     '[ '("output_size", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-_contrib_AdaptiveAvgPooling2D ::
-                              forall args .
-                                Fullfilled "_contrib_AdaptiveAvgPooling2D(symbol)" args =>
-                                String ->
-                                  ArgsHMap "_contrib_AdaptiveAvgPooling2D(symbol)" args ->
-                                    IO SymbolHandle
-_contrib_AdaptiveAvgPooling2D name args
-  = let scalarArgs
-          = catMaybes
-              [("output_size",) . showValue <$>
-                 (args !? #output_size :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_contrib_AdaptiveAvgPooling2D(symbol)" =
-     '[]
-
-_backward_contrib_AdaptiveAvgPooling2D ::
-                                       forall args .
-                                         Fullfilled "_backward_contrib_AdaptiveAvgPooling2D(symbol)"
-                                           args =>
-                                         String ->
-                                           ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(symbol)"
-                                             args
-                                             -> IO SymbolHandle
-_backward_contrib_AdaptiveAvgPooling2D name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_to_tensor(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_image_to_tensor ::
-                 forall args . Fullfilled "_image_to_tensor(symbol)" args =>
-                   String ->
-                     ArgsHMap "_image_to_tensor(symbol)" args -> IO SymbolHandle
-_image_to_tensor name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_to_tensor"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_normalize(symbol)" =
-     '[ '("mean", AttrReq [Float]), '("std", AttrReq [Float]),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_normalize ::
-                 forall args . Fullfilled "_image_normalize(symbol)" args =>
-                   String ->
-                     ArgsHMap "_image_normalize(symbol)" args -> IO SymbolHandle
-_image_normalize name args
-  = let scalarArgs
-          = catMaybes
-              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),
-               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_normalize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_flip_left_right(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_image_flip_left_right ::
-                       forall args . Fullfilled "_image_flip_left_right(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_flip_left_right(symbol)" args -> IO SymbolHandle
-_image_flip_left_right name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_left_right"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_flip_left_right(symbol)"
-     = '[ '("data", AttrOpt SymbolHandle)]
-
-_image_random_flip_left_right ::
-                              forall args .
-                                Fullfilled "_image_random_flip_left_right(symbol)" args =>
-                                String ->
-                                  ArgsHMap "_image_random_flip_left_right(symbol)" args ->
-                                    IO SymbolHandle
-_image_random_flip_left_right name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_left_right"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_flip_top_bottom(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_image_flip_top_bottom ::
-                       forall args . Fullfilled "_image_flip_top_bottom(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_flip_top_bottom(symbol)" args -> IO SymbolHandle
-_image_flip_top_bottom name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_top_bottom"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_flip_top_bottom(symbol)"
-     = '[ '("data", AttrOpt SymbolHandle)]
-
-_image_random_flip_top_bottom ::
-                              forall args .
-                                Fullfilled "_image_random_flip_top_bottom(symbol)" args =>
-                                String ->
-                                  ArgsHMap "_image_random_flip_top_bottom(symbol)" args ->
-                                    IO SymbolHandle
-_image_random_flip_top_bottom name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_top_bottom"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_brightness(symbol)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_brightness ::
-                         forall args . Fullfilled "_image_random_brightness(symbol)" args =>
-                           String ->
-                             ArgsHMap "_image_random_brightness(symbol)" args -> IO SymbolHandle
-_image_random_brightness name args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_brightness"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_contrast(symbol)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_contrast ::
-                       forall args . Fullfilled "_image_random_contrast(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_random_contrast(symbol)" args -> IO SymbolHandle
-_image_random_contrast name args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_contrast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_saturation(symbol)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_saturation ::
-                         forall args . Fullfilled "_image_random_saturation(symbol)" args =>
-                           String ->
-                             ArgsHMap "_image_random_saturation(symbol)" args -> IO SymbolHandle
-_image_random_saturation name args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_saturation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_hue(symbol)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_hue ::
-                  forall args . Fullfilled "_image_random_hue(symbol)" args =>
-                    String ->
-                      ArgsHMap "_image_random_hue(symbol)" args -> IO SymbolHandle
-_image_random_hue name args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_hue"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_color_jitter(symbol)" =
-     '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float),
-        '("saturation", AttrReq Float), '("hue", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_color_jitter ::
-                           forall args .
-                             Fullfilled "_image_random_color_jitter(symbol)" args =>
-                             String ->
-                               ArgsHMap "_image_random_color_jitter(symbol)" args ->
-                                 IO SymbolHandle
-_image_random_color_jitter name args
-  = let scalarArgs
-          = catMaybes
-              [("brightness",) . showValue <$>
-                 (args !? #brightness :: Maybe Float),
-               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
-               ("saturation",) . showValue <$>
-                 (args !? #saturation :: Maybe Float),
-               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_color_jitter"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_adjust_lighting(symbol)" =
-     '[ '("alpha", AttrReq [Float]), '("data", AttrOpt SymbolHandle)]
-
-_image_adjust_lighting ::
-                       forall args . Fullfilled "_image_adjust_lighting(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_adjust_lighting(symbol)" args -> IO SymbolHandle
-_image_adjust_lighting name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_adjust_lighting"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_lighting(symbol)" =
-     '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_image_random_lighting ::
-                       forall args . Fullfilled "_image_random_lighting(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_random_lighting(symbol)" args -> IO SymbolHandle
-_image_random_lighting name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha_std",) . showValue <$>
-                 (args !? #alpha_std :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_lighting"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "softmax(symbol)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("data", AttrOpt SymbolHandle)]
-
-softmax ::
-        forall args . Fullfilled "softmax(symbol)" args =>
-          String -> ArgsHMap "softmax(symbol)" args -> IO SymbolHandle
-softmax name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_softmax(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_softmax ::
-                  forall args . Fullfilled "_backward_softmax(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_softmax(symbol)" args -> IO SymbolHandle
-_backward_softmax name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "softmin(symbol)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("data", AttrOpt SymbolHandle)]
-
-softmin ::
-        forall args . Fullfilled "softmin(symbol)" args =>
-          String -> ArgsHMap "softmin(symbol)" args -> IO SymbolHandle
-softmin name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_softmin(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_softmin ::
-                  forall args . Fullfilled "_backward_softmin(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_softmin(symbol)" args -> IO SymbolHandle
-_backward_softmin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log_softmax(symbol)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("data", AttrOpt SymbolHandle)]
-
-log_softmax ::
-            forall args . Fullfilled "log_softmax(symbol)" args =>
-              String -> ArgsHMap "log_softmax(symbol)" args -> IO SymbolHandle
-log_softmax name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log_softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log_softmax(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log_softmax ::
-                      forall args . Fullfilled "_backward_log_softmax(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_log_softmax(symbol)" args -> IO SymbolHandle
-_backward_log_softmax name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log_softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Pooling(symbol)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),
-        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
-        '("pooling_convention",
-          AttrOpt (EnumType '["full", "same", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("p_value", AttrOpt (Maybe Int)),
-        '("count_include_pad", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt SymbolHandle)]
-
-_Pooling ::
-         forall args . Fullfilled "_Pooling(symbol)" args =>
-           String -> ArgsHMap "_Pooling(symbol)" args -> IO SymbolHandle
-_Pooling name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "same", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Pooling(symbol)" = '[]
-
-_backward_Pooling ::
-                  forall args . Fullfilled "_backward_Pooling(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_Pooling(symbol)" args -> IO SymbolHandle
-_backward_Pooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Deconvolution(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle)]
-
-_Deconvolution ::
-               forall args . Fullfilled "_Deconvolution(symbol)" args =>
-                 String -> ArgsHMap "_Deconvolution(symbol)" args -> IO SymbolHandle
-_Deconvolution name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Deconvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Deconvolution(symbol)" = '[]
-
-_backward_Deconvolution ::
-                        forall args . Fullfilled "_backward_Deconvolution(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_Deconvolution(symbol)" args -> IO SymbolHandle
-_backward_Deconvolution name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Deconvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Activation(symbol)" =
-     '[ '("act_type",
-          AttrReq
-            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_Activation ::
-            forall args . Fullfilled "_Activation(symbol)" args =>
-              String -> ArgsHMap "_Activation(symbol)" args -> IO SymbolHandle
-_Activation name args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Activation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Activation(symbol)" = '[]
-
-_backward_Activation ::
-                     forall args . Fullfilled "_backward_Activation(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_Activation(symbol)" args -> IO SymbolHandle
-_backward_Activation name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Activation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_UpSampling(symbol)" =
-     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),
-        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),
-        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),
-        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-_UpSampling ::
-            forall args . Fullfilled "_UpSampling(symbol)" args =>
-              String -> ArgsHMap "_UpSampling(symbol)" args -> IO SymbolHandle
-_UpSampling name args
-  = let scalarArgs
-          = catMaybes
-              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("sample_type",) . showValue <$>
-                 (args !? #sample_type ::
-                    Maybe (EnumType '["bilinear", "nearest"])),
-               ("multi_input_mode",) . showValue <$>
-                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "UpSampling"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_UpSampling(symbol)" = '[]
-
-_backward_UpSampling ::
-                     forall args . Fullfilled "_backward_UpSampling(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_UpSampling(symbol)" args -> IO SymbolHandle
-_backward_UpSampling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_UpSampling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BatchNorm(symbol)" =
-     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),
-        '("moving_mean", AttrOpt SymbolHandle),
-        '("moving_var", AttrOpt SymbolHandle)]
-
-_BatchNorm ::
-           forall args . Fullfilled "_BatchNorm(symbol)" args =>
-             String -> ArgsHMap "_BatchNorm(symbol)" args -> IO SymbolHandle
-_BatchNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_BatchNorm(symbol)" = '[]
-
-_backward_BatchNorm ::
-                    forall args . Fullfilled "_backward_BatchNorm(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_BatchNorm(symbol)" args -> IO SymbolHandle
-_backward_BatchNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CTCLoss(symbol)" =
-     '[ '("use_data_lengths", AttrOpt Bool),
-        '("use_label_lengths", AttrOpt Bool),
-        '("blank_label", AttrOpt (EnumType '["first", "last"])),
-        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle),
-        '("data_lengths", AttrOpt SymbolHandle),
-        '("label_lengths", AttrOpt SymbolHandle)]
-
-_CTCLoss ::
-         forall args . Fullfilled "_CTCLoss(symbol)" args =>
-           String -> ArgsHMap "_CTCLoss(symbol)" args -> IO SymbolHandle
-_CTCLoss name args
-  = let scalarArgs
-          = catMaybes
-              [("use_data_lengths",) . showValue <$>
-                 (args !? #use_data_lengths :: Maybe Bool),
-               ("use_label_lengths",) . showValue <$>
-                 (args !? #use_label_lengths :: Maybe Bool),
-               ("blank_label",) . showValue <$>
-                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle),
-               ("data_lengths",) <$>
-                 (args !? #data_lengths :: Maybe SymbolHandle),
-               ("label_lengths",) <$>
-                 (args !? #label_lengths :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CTCLoss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_ctc_loss(symbol)" = '[]
-
-_backward_ctc_loss ::
-                   forall args . Fullfilled "_backward_ctc_loss(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_ctc_loss(symbol)" args -> IO SymbolHandle
-_backward_ctc_loss name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ctc_loss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_FullyConnected(symbol)" =
-     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
-        '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]
-
-_FullyConnected ::
-                forall args . Fullfilled "_FullyConnected(symbol)" args =>
-                  String ->
-                    ArgsHMap "_FullyConnected(symbol)" args -> IO SymbolHandle
-_FullyConnected name args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "FullyConnected"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_FullyConnected(symbol)" =
-     '[]
-
-_backward_FullyConnected ::
-                         forall args . Fullfilled "_backward_FullyConnected(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_FullyConnected(symbol)" args -> IO SymbolHandle
-_backward_FullyConnected name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_FullyConnected"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Convolution(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle)]
-
-_Convolution ::
-             forall args . Fullfilled "_Convolution(symbol)" args =>
-               String -> ArgsHMap "_Convolution(symbol)" args -> IO SymbolHandle
-_Convolution name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Convolution(symbol)" = '[]
-
-_backward_Convolution ::
-                      forall args . Fullfilled "_backward_Convolution(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_Convolution(symbol)" args -> IO SymbolHandle
-_backward_Convolution name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LayerNorm(symbol)" =
-     '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float),
-        '("output_mean_var", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle),
-        '("beta", AttrOpt SymbolHandle)]
-
-_LayerNorm ::
-           forall args . Fullfilled "_LayerNorm(symbol)" args =>
-             String -> ArgsHMap "_LayerNorm(symbol)" args -> IO SymbolHandle
-_LayerNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LayerNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_LayerNorm(symbol)" = '[]
-
-_backward_LayerNorm ::
-                    forall args . Fullfilled "_backward_LayerNorm(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_LayerNorm(symbol)" args -> IO SymbolHandle
-_backward_LayerNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LayerNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Concat(symbol)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-_Concat ::
-        forall args . Fullfilled "_Concat(symbol)" args =>
-          String -> ArgsHMap "_Concat(symbol)" args -> IO SymbolHandle
-_Concat name args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "Concat"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_Concat(symbol)" = '[]
-
-_backward_Concat ::
-                 forall args . Fullfilled "_backward_Concat(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_Concat(symbol)" args -> IO SymbolHandle
-_backward_Concat name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Concat"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rnn_param_concat(symbol)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-_rnn_param_concat ::
-                  forall args . Fullfilled "_rnn_param_concat(symbol)" args =>
-                    String ->
-                      ArgsHMap "_rnn_param_concat(symbol)" args -> IO SymbolHandle
-_rnn_param_concat name args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "_rnn_param_concat"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_SoftmaxActivation(symbol)" =
-     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_SoftmaxActivation ::
-                   forall args . Fullfilled "_SoftmaxActivation(symbol)" args =>
-                     String ->
-                       ArgsHMap "_SoftmaxActivation(symbol)" args -> IO SymbolHandle
-_SoftmaxActivation name args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxActivation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SoftmaxActivation(symbol)" =
-     '[]
-
-_backward_SoftmaxActivation ::
-                            forall args .
-                              Fullfilled "_backward_SoftmaxActivation(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_SoftmaxActivation(symbol)" args ->
-                                  IO SymbolHandle
-_backward_SoftmaxActivation name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxActivation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LRN(symbol)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),
-        '("data", AttrOpt SymbolHandle)]
-
-_LRN ::
-     forall args . Fullfilled "_LRN(symbol)" args =>
-       String -> ArgsHMap "_LRN(symbol)" args -> IO SymbolHandle
-_LRN name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),
-               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LRN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_LRN(symbol)" = '[]
-
-_backward_LRN ::
-              forall args . Fullfilled "_backward_LRN(symbol)" args =>
-                String -> ArgsHMap "_backward_LRN(symbol)" args -> IO SymbolHandle
-_backward_LRN name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LRN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Dropout(symbol)" =
-     '[ '("p", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["always", "training"])),
-        '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-_Dropout ::
-         forall args . Fullfilled "_Dropout(symbol)" args =>
-           String -> ArgsHMap "_Dropout(symbol)" args -> IO SymbolHandle
-_Dropout name args
-  = let scalarArgs
-          = catMaybes
-              [("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["always", "training"])),
-               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Dropout"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Dropout(symbol)" = '[]
-
-_backward_Dropout ::
-                  forall args . Fullfilled "_backward_Dropout(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_Dropout(symbol)" args -> IO SymbolHandle
-_backward_Dropout name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Dropout"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_dequantize(symbol)" =
-     '[ '("out_type", AttrOpt (EnumType '["float32"])),
-        '("data", AttrOpt SymbolHandle),
-        '("min_range", AttrOpt SymbolHandle),
-        '("max_range", AttrOpt SymbolHandle)]
-
-_contrib_dequantize ::
-                    forall args . Fullfilled "_contrib_dequantize(symbol)" args =>
-                      String ->
-                        ArgsHMap "_contrib_dequantize(symbol)" args -> IO SymbolHandle
-_contrib_dequantize name args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["float32"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dequantize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantized_flatten(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("min_data", AttrOpt SymbolHandle),
-        '("max_data", AttrOpt SymbolHandle)]
-
-_contrib_quantized_flatten ::
-                           forall args .
-                             Fullfilled "_contrib_quantized_flatten(symbol)" args =>
-                             String ->
-                               ArgsHMap "_contrib_quantized_flatten(symbol)" args ->
-                                 IO SymbolHandle
-_contrib_quantized_flatten name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_flatten"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantized_conv(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle),
-        '("min_data", AttrOpt SymbolHandle),
-        '("max_data", AttrOpt SymbolHandle),
-        '("min_weight", AttrOpt SymbolHandle),
-        '("max_weight", AttrOpt SymbolHandle),
-        '("min_bias", AttrOpt SymbolHandle),
-        '("max_bias", AttrOpt SymbolHandle)]
-
-_contrib_quantized_conv ::
-                        forall args . Fullfilled "_contrib_quantized_conv(symbol)" args =>
-                          String ->
-                            ArgsHMap "_contrib_quantized_conv(symbol)" args -> IO SymbolHandle
-_contrib_quantized_conv name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_conv"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_contrib_quantized_fully_connected(symbol)" =
-     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
-        '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle),
-        '("min_data", AttrOpt SymbolHandle),
-        '("max_data", AttrOpt SymbolHandle),
-        '("min_weight", AttrOpt SymbolHandle),
-        '("max_weight", AttrOpt SymbolHandle),
-        '("min_bias", AttrOpt SymbolHandle),
-        '("max_bias", AttrOpt SymbolHandle)]
-
-_contrib_quantized_fully_connected ::
-                                   forall args .
-                                     Fullfilled "_contrib_quantized_fully_connected(symbol)" args =>
-                                     String ->
-                                       ArgsHMap "_contrib_quantized_fully_connected(symbol)" args ->
-                                         IO SymbolHandle
-_contrib_quantized_fully_connected name args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantized_pooling(symbol)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),
-        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
-        '("pooling_convention",
-          AttrOpt (EnumType '["full", "same", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("p_value", AttrOpt (Maybe Int)),
-        '("count_include_pad", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt SymbolHandle),
-        '("min_data", AttrOpt SymbolHandle),
-        '("max_data", AttrOpt SymbolHandle)]
-
-_contrib_quantized_pooling ::
-                           forall args .
-                             Fullfilled "_contrib_quantized_pooling(symbol)" args =>
-                             String ->
-                               ArgsHMap "_contrib_quantized_pooling(symbol)" args ->
-                                 IO SymbolHandle
-_contrib_quantized_pooling name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "same", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_pooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantized_concat(symbol)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-_contrib_quantized_concat ::
-                          forall args .
-                            Fullfilled "_contrib_quantized_concat(symbol)" args =>
-                            String ->
-                              ArgsHMap "_contrib_quantized_concat(symbol)" args ->
-                                IO SymbolHandle
-_contrib_quantized_concat name args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_concat"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_contrib_requantize(symbol)" =
-     '[ '("min_calib_range", AttrOpt (Maybe Float)),
-        '("max_calib_range", AttrOpt (Maybe Float)),
-        '("data", AttrOpt SymbolHandle),
-        '("min_range", AttrOpt SymbolHandle),
-        '("max_range", AttrOpt SymbolHandle)]
-
-_contrib_requantize ::
-                    forall args . Fullfilled "_contrib_requantize(symbol)" args =>
-                      String ->
-                        ArgsHMap "_contrib_requantize(symbol)" args -> IO SymbolHandle
-_contrib_requantize name args
-  = let scalarArgs
-          = catMaybes
-              [("min_calib_range",) . showValue <$>
-                 (args !? #min_calib_range :: Maybe (Maybe Float)),
-               ("max_calib_range",) . showValue <$>
-                 (args !? #max_calib_range :: Maybe (Maybe Float))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_requantize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantize(symbol)" =
-     '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])),
-        '("data", AttrOpt SymbolHandle),
-        '("min_range", AttrOpt SymbolHandle),
-        '("max_range", AttrOpt SymbolHandle)]
-
-_contrib_quantize ::
-                  forall args . Fullfilled "_contrib_quantize(symbol)" args =>
-                    String ->
-                      ArgsHMap "_contrib_quantize(symbol)" args -> IO SymbolHandle
-_contrib_quantize name args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_cvimread(symbol)" =
-     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),
-        '("to_rgb", AttrOpt Bool)]
-
-_cvimread ::
-          forall args . Fullfilled "_cvimread(symbol)" args =>
-            String -> ArgsHMap "_cvimread(symbol)" args -> IO SymbolHandle
-_cvimread name args
-  = let scalarArgs
-          = catMaybes
-              [("filename",) . showValue <$> (args !? #filename :: Maybe String),
-               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimread"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_NoGradient(symbol)" = '[]
-
-_NoGradient ::
-            forall args . Fullfilled "_NoGradient(symbol)" args =>
-              String -> ArgsHMap "_NoGradient(symbol)" args -> IO SymbolHandle
-_NoGradient name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_NoGradient"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CachedOp(symbol)" =
-     '[ '("data", AttrOpt [SymbolHandle])]
-
-_CachedOp ::
-          forall args . Fullfilled "_CachedOp(symbol)" args =>
-            String -> ArgsHMap "_CachedOp(symbol)" args -> IO SymbolHandle
-_CachedOp name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "_CachedOp"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_CachedOp(symbol)" = '[]
-
-_backward_CachedOp ::
-                   forall args . Fullfilled "_backward_CachedOp(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_CachedOp(symbol)" args -> IO SymbolHandle
-_backward_CachedOp name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CachedOp"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "softmax_cross_entropy(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-softmax_cross_entropy ::
-                      forall args . Fullfilled "softmax_cross_entropy(symbol)" args =>
-                        String ->
-                          ArgsHMap "softmax_cross_entropy(symbol)" args -> IO SymbolHandle
-softmax_cross_entropy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax_cross_entropy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_softmax_cross_entropy(symbol)" = '[]
-
-_backward_softmax_cross_entropy ::
-                                forall args .
-                                  Fullfilled "_backward_softmax_cross_entropy(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_backward_softmax_cross_entropy(symbol)" args ->
-                                      IO SymbolHandle
-_backward_softmax_cross_entropy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Pad(symbol)" =
-     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),
-        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),
-        '("data", AttrOpt SymbolHandle)]
-
-_Pad ::
-     forall args . Fullfilled "_Pad(symbol)" args =>
-       String -> ArgsHMap "_Pad(symbol)" args -> IO SymbolHandle
-_Pad name args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["constant", "edge", "reflect"])),
-               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),
-               ("constant_value",) . showValue <$>
-                 (args !? #constant_value :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pad"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_foreach(symbol)" = '[]
-
-_backward_foreach ::
-                  forall args . Fullfilled "_backward_foreach(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_foreach(symbol)" args -> IO SymbolHandle
-_backward_foreach name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_foreach"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_while_loop(symbol)" = '[]
-
-_backward_while_loop ::
-                     forall args . Fullfilled "_backward_while_loop(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_while_loop(symbol)" args -> IO SymbolHandle
-_backward_while_loop name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_while_loop"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cond(symbol)" = '[]
-
-_backward_cond ::
-               forall args . Fullfilled "_backward_cond(symbol)" args =>
-                 String -> ArgsHMap "_backward_cond(symbol)" args -> IO SymbolHandle
-_backward_cond name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cond"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LeakyReLU(symbol)" =
-     '[ '("act_type",
-          AttrOpt (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),
-        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),
-        '("upper_bound", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle)]
-
-_LeakyReLU ::
-           forall args . Fullfilled "_LeakyReLU(symbol)" args =>
-             String -> ArgsHMap "_LeakyReLU(symbol)" args -> IO SymbolHandle
-_LeakyReLU name args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe (EnumType '["elu", "leaky", "prelu", "rrelu", "selu"])),
-               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),
-               ("lower_bound",) . showValue <$>
-                 (args !? #lower_bound :: Maybe Float),
-               ("upper_bound",) . showValue <$>
-                 (args !? #upper_bound :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LeakyReLU"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SwapAxis(symbol)" =
-     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle)]
-
-_SwapAxis ::
-          forall args . Fullfilled "_SwapAxis(symbol)" args =>
-            String -> ArgsHMap "_SwapAxis(symbol)" args -> IO SymbolHandle
-_SwapAxis name args
-  = let scalarArgs
-          = catMaybes
-              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),
-               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SwapAxis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_IdentityAttachKLSparseReg(symbol)" =
-     '[ '("sparseness_target", AttrOpt Float),
-        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_IdentityAttachKLSparseReg ::
-                           forall args .
-                             Fullfilled "_IdentityAttachKLSparseReg(symbol)" args =>
-                             String ->
-                               ArgsHMap "_IdentityAttachKLSparseReg(symbol)" args ->
-                                 IO SymbolHandle
-_IdentityAttachKLSparseReg name args
-  = let scalarArgs
-          = catMaybes
-              [("sparseness_target",) . showValue <$>
-                 (args !? #sparseness_target :: Maybe Float),
-               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SliceChannel(symbol)" =
-     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),
-        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-_SliceChannel ::
-              forall args . Fullfilled "_SliceChannel(symbol)" args =>
-                String -> ArgsHMap "_SliceChannel(symbol)" args -> IO SymbolHandle
-_SliceChannel name args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SliceChannel"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BatchNorm_v1(symbol)" =
-     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle),
-        '("beta", AttrOpt SymbolHandle)]
-
-_BatchNorm_v1 ::
-              forall args . Fullfilled "_BatchNorm_v1(symbol)" args =>
-                String -> ArgsHMap "_BatchNorm_v1(symbol)" args -> IO SymbolHandle
-_BatchNorm_v1 name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "signsgd_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)]
-
-signsgd_update ::
-               forall args . Fullfilled "signsgd_update(symbol)" args =>
-                 String -> ArgsHMap "signsgd_update(symbol)" args -> IO SymbolHandle
-signsgd_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signsgd_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "signum_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mom", AttrOpt SymbolHandle)]
-
-signum_update ::
-              forall args . Fullfilled "signum_update(symbol)" args =>
-                String -> ArgsHMap "signum_update(symbol)" args -> IO SymbolHandle
-signum_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signum_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sgd_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)]
-
-sgd_update ::
-           forall args . Fullfilled "sgd_update(symbol)" args =>
-             String -> ArgsHMap "sgd_update(symbol)" args -> IO SymbolHandle
-sgd_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sgd_mom_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mom", AttrOpt SymbolHandle)]
-
-sgd_mom_update ::
-               forall args . Fullfilled "sgd_mom_update(symbol)" args =>
-                 String -> ArgsHMap "sgd_mom_update(symbol)" args -> IO SymbolHandle
-sgd_mom_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_mom_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "mp_sgd_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("weight32", AttrOpt SymbolHandle)]
-
-mp_sgd_update ::
-              forall args . Fullfilled "mp_sgd_update(symbol)" args =>
-                String -> ArgsHMap "mp_sgd_update(symbol)" args -> IO SymbolHandle
-mp_sgd_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "mp_sgd_mom_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mom", AttrOpt SymbolHandle),
-        '("weight32", AttrOpt SymbolHandle)]
-
-mp_sgd_mom_update ::
-                  forall args . Fullfilled "mp_sgd_mom_update(symbol)" args =>
-                    String ->
-                      ArgsHMap "mp_sgd_mom_update(symbol)" args -> IO SymbolHandle
-mp_sgd_mom_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_mom_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ftml_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double),
-        '("t", AttrReq Int), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("d", AttrOpt SymbolHandle), '("v", AttrOpt SymbolHandle),
-        '("z", AttrOpt SymbolHandle)]
-
-ftml_update ::
-            forall args . Fullfilled "ftml_update(symbol)" args =>
-              String -> ArgsHMap "ftml_update(symbol)" args -> IO SymbolHandle
-ftml_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),
-               ("t",) . showValue <$> (args !? #t :: Maybe Int),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("d",) <$> (args !? #d :: Maybe SymbolHandle),
-               ("v",) <$> (args !? #v :: Maybe SymbolHandle),
-               ("z",) <$> (args !? #z :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftml_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "adam_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle)]
-
-adam_update ::
-            forall args . Fullfilled "adam_update(symbol)" args =>
-              String -> ArgsHMap "adam_update(symbol)" args -> IO SymbolHandle
-adam_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mean",) <$> (args !? #mean :: Maybe SymbolHandle),
-               ("var",) <$> (args !? #var :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "adam_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rmsprop_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("n", AttrOpt SymbolHandle)]
-
-rmsprop_update ::
-               forall args . Fullfilled "rmsprop_update(symbol)" args =>
-                 String -> ArgsHMap "rmsprop_update(symbol)" args -> IO SymbolHandle
-rmsprop_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmsprop_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rmspropalex_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("n", AttrOpt SymbolHandle), '("g", AttrOpt SymbolHandle),
-        '("delta", AttrOpt SymbolHandle)]
-
-rmspropalex_update ::
-                   forall args . Fullfilled "rmspropalex_update(symbol)" args =>
-                     String ->
-                       ArgsHMap "rmspropalex_update(symbol)" args -> IO SymbolHandle
-rmspropalex_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("n",) <$> (args !? #n :: Maybe SymbolHandle),
-               ("g",) <$> (args !? #g :: Maybe SymbolHandle),
-               ("delta",) <$> (args !? #delta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmspropalex_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ftrl_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),
-        '("beta", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("z", AttrOpt SymbolHandle), '("n", AttrOpt SymbolHandle)]
-
-ftrl_update ::
-            forall args . Fullfilled "ftrl_update(symbol)" args =>
-              String -> ArgsHMap "ftrl_update(symbol)" args -> IO SymbolHandle
-ftrl_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("z",) <$> (args !? #z :: Maybe SymbolHandle),
-               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftrl_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sparse_adagrad_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("history", AttrOpt SymbolHandle)]
-
-_sparse_adagrad_update ::
-                       forall args . Fullfilled "_sparse_adagrad_update(symbol)" args =>
-                         String ->
-                           ArgsHMap "_sparse_adagrad_update(symbol)" args -> IO SymbolHandle
-_sparse_adagrad_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("history",) <$> (args !? #history :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_adagrad_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LinearRegressionOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_LinearRegressionOutput ::
-                        forall args . Fullfilled "_LinearRegressionOutput(symbol)" args =>
-                          String ->
-                            ArgsHMap "_LinearRegressionOutput(symbol)" args -> IO SymbolHandle
-_LinearRegressionOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LinearRegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linear_reg_out(symbol)" =
-     '[]
-
-_backward_linear_reg_out ::
-                         forall args . Fullfilled "_backward_linear_reg_out(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_linear_reg_out(symbol)" args -> IO SymbolHandle
-_backward_linear_reg_out name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linear_reg_out"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_MAERegressionOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_MAERegressionOutput ::
-                     forall args . Fullfilled "_MAERegressionOutput(symbol)" args =>
-                       String ->
-                         ArgsHMap "_MAERegressionOutput(symbol)" args -> IO SymbolHandle
-_MAERegressionOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MAERegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mae_reg_out(symbol)" = '[]
-
-_backward_mae_reg_out ::
-                      forall args . Fullfilled "_backward_mae_reg_out(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_mae_reg_out(symbol)" args -> IO SymbolHandle
-_backward_mae_reg_out name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mae_reg_out"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LogisticRegressionOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_LogisticRegressionOutput ::
-                          forall args .
-                            Fullfilled "_LogisticRegressionOutput(symbol)" args =>
-                            String ->
-                              ArgsHMap "_LogisticRegressionOutput(symbol)" args ->
-                                IO SymbolHandle
-_LogisticRegressionOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LogisticRegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_logistic_reg_out(symbol)" =
-     '[]
-
-_backward_logistic_reg_out ::
-                           forall args .
-                             Fullfilled "_backward_logistic_reg_out(symbol)" args =>
-                             String ->
-                               ArgsHMap "_backward_logistic_reg_out(symbol)" args ->
-                                 IO SymbolHandle
-_backward_logistic_reg_out name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_logistic_reg_out"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CustomFunction(symbol)" = '[]
-
-_CustomFunction ::
-                forall args . Fullfilled "_CustomFunction(symbol)" args =>
-                  String ->
-                    ArgsHMap "_CustomFunction(symbol)" args -> IO SymbolHandle
-_CustomFunction name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CustomFunction"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_CustomFunction(symbol)" =
-     '[]
-
-_backward_CustomFunction ::
-                         forall args . Fullfilled "_backward_CustomFunction(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_CustomFunction(symbol)" args -> IO SymbolHandle
-_backward_CustomFunction name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CustomFunction"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__Native(symbol)" = '[]
-
-_backward__Native ::
-                  forall args . Fullfilled "_backward__Native(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward__Native(symbol)" args -> IO SymbolHandle
-_backward__Native name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__Native"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__NDArray(symbol)" = '[]
-
-_backward__NDArray ::
-                   forall args . Fullfilled "_backward__NDArray(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward__NDArray(symbol)" args -> IO SymbolHandle
-_backward__NDArray name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__NDArray"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiBoxTarget(symbol)" =
-     '[ '("overlap_threshold", AttrOpt Float),
-        '("ignore_label", AttrOpt Float),
-        '("negative_mining_ratio", AttrOpt Float),
-        '("negative_mining_thresh", AttrOpt Float),
-        '("minimum_negative_samples", AttrOpt Int),
-        '("variances", AttrOpt [Float]), '("anchor", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle),
-        '("cls_pred", AttrOpt SymbolHandle)]
-
-_contrib_MultiBoxTarget ::
-                        forall args . Fullfilled "_contrib_MultiBoxTarget(symbol)" args =>
-                          String ->
-                            ArgsHMap "_contrib_MultiBoxTarget(symbol)" args -> IO SymbolHandle
-_contrib_MultiBoxTarget name args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_threshold",) . showValue <$>
-                 (args !? #overlap_threshold :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("negative_mining_ratio",) . showValue <$>
-                 (args !? #negative_mining_ratio :: Maybe Float),
-               ("negative_mining_thresh",) . showValue <$>
-                 (args !? #negative_mining_thresh :: Maybe Float),
-               ("minimum_negative_samples",) . showValue <$>
-                 (args !? #minimum_negative_samples :: Maybe Int),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle),
-               ("cls_pred",) <$> (args !? #cls_pred :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxTarget(symbol)" = '[]
-
-_backward__contrib_MultiBoxTarget ::
-                                  forall args .
-                                    Fullfilled "_backward__contrib_MultiBoxTarget(symbol)" args =>
-                                    String ->
-                                      ArgsHMap "_backward__contrib_MultiBoxTarget(symbol)" args ->
-                                        IO SymbolHandle
-_backward__contrib_MultiBoxTarget name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_Proposal(symbol)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle),
-        '("bbox_pred", AttrOpt SymbolHandle),
-        '("im_info", AttrOpt SymbolHandle)]
-
-_contrib_Proposal ::
-                  forall args . Fullfilled "_contrib_Proposal(symbol)" args =>
-                    String ->
-                      ArgsHMap "_contrib_Proposal(symbol)" args -> IO SymbolHandle
-_contrib_Proposal name args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_Proposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__contrib_Proposal(symbol)" =
-     '[]
-
-_backward__contrib_Proposal ::
-                            forall args .
-                              Fullfilled "_backward__contrib_Proposal(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward__contrib_Proposal(symbol)" args ->
-                                  IO SymbolHandle
-_backward__contrib_Proposal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_Proposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_count_sketch(symbol)" =
-     '[ '("out_dim", AttrReq Int),
-        '("processing_batch_size", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle), '("h", AttrOpt SymbolHandle),
-        '("s", AttrOpt SymbolHandle)]
-
-_contrib_count_sketch ::
-                      forall args . Fullfilled "_contrib_count_sketch(symbol)" args =>
-                        String ->
-                          ArgsHMap "_contrib_count_sketch(symbol)" args -> IO SymbolHandle
-_contrib_count_sketch name args
-  = let scalarArgs
-          = catMaybes
-              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),
-               ("processing_batch_size",) . showValue <$>
-                 (args !? #processing_batch_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("h",) <$> (args !? #h :: Maybe SymbolHandle),
-               ("s",) <$> (args !? #s :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_count_sketch"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_count_sketch(symbol)" = '[]
-
-_backward__contrib_count_sketch ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_count_sketch(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_backward__contrib_count_sketch(symbol)" args ->
-                                      IO SymbolHandle
-_backward__contrib_count_sketch name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_count_sketch"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiBoxDetection(symbol)" =
-     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),
-        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),
-        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),
-        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt SymbolHandle),
-        '("loc_pred", AttrOpt SymbolHandle),
-        '("anchor", AttrOpt SymbolHandle)]
-
-_contrib_MultiBoxDetection ::
-                           forall args .
-                             Fullfilled "_contrib_MultiBoxDetection(symbol)" args =>
-                             String ->
-                               ArgsHMap "_contrib_MultiBoxDetection(symbol)" args ->
-                                 IO SymbolHandle
-_contrib_MultiBoxDetection name args
-  = let scalarArgs
-          = catMaybes
-              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("nms_threshold",) . showValue <$>
-                 (args !? #nms_threshold :: Maybe Float),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float]),
-               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),
-               ("loc_pred",) <$> (args !? #loc_pred :: Maybe SymbolHandle),
-               ("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxDetection(symbol)" = '[]
-
-_backward__contrib_MultiBoxDetection ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiBoxDetection(symbol)"
-                                         args =>
-                                       String ->
-                                         ArgsHMap "_backward__contrib_MultiBoxDetection(symbol)"
-                                           args
-                                           -> IO SymbolHandle
-_backward__contrib_MultiBoxDetection name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_contrib_DeformablePSROIPooling(symbol)" =
-     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),
-        '("group_size", AttrReq Int), '("pooled_size", AttrReq Int),
-        '("part_size", AttrOpt Int), '("sample_per_part", AttrOpt Int),
-        '("trans_std", AttrOpt Float), '("no_trans", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle),
-        '("trans", AttrOpt SymbolHandle)]
-
-_contrib_DeformablePSROIPooling ::
-                                forall args .
-                                  Fullfilled "_contrib_DeformablePSROIPooling(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_contrib_DeformablePSROIPooling(symbol)" args ->
-                                      IO SymbolHandle
-_contrib_DeformablePSROIPooling name args
-  = let scalarArgs
-          = catMaybes
-              [("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int),
-               ("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe Int),
-               ("part_size",) . showValue <$> (args !? #part_size :: Maybe Int),
-               ("sample_per_part",) . showValue <$>
-                 (args !? #sample_per_part :: Maybe Int),
-               ("trans_std",) . showValue <$> (args !? #trans_std :: Maybe Float),
-               ("no_trans",) . showValue <$> (args !? #no_trans :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle),
-               ("trans",) <$> (args !? #trans :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformablePSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_DeformablePSROIPooling(symbol)" =
-     '[]
-
-_backward__contrib_DeformablePSROIPooling ::
-                                          forall args .
-                                            Fullfilled
-                                              "_backward__contrib_DeformablePSROIPooling(symbol)"
-                                              args =>
-                                            String ->
-                                              ArgsHMap
-                                                "_backward__contrib_DeformablePSROIPooling(symbol)"
-                                                args
-                                                -> IO SymbolHandle
-_backward__contrib_DeformablePSROIPooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_fft(symbol)" =
-     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-_contrib_fft ::
-             forall args . Fullfilled "_contrib_fft(symbol)" args =>
-               String -> ArgsHMap "_contrib_fft(symbol)" args -> IO SymbolHandle
-_contrib_fft name args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_fft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__contrib_fft(symbol)" = '[]
-
-_backward__contrib_fft ::
-                       forall args . Fullfilled "_backward__contrib_fft(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward__contrib_fft(symbol)" args -> IO SymbolHandle
-_backward__contrib_fft name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_fft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiBoxPrior(symbol)" =
-     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),
-        '("offsets", AttrOpt [Float]), '("data", AttrOpt SymbolHandle)]
-
-_contrib_MultiBoxPrior ::
-                       forall args . Fullfilled "_contrib_MultiBoxPrior(symbol)" args =>
-                         String ->
-                           ArgsHMap "_contrib_MultiBoxPrior(symbol)" args -> IO SymbolHandle
-_contrib_MultiBoxPrior name args
-  = let scalarArgs
-          = catMaybes
-              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),
-               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxPrior(symbol)" = '[]
-
-_backward__contrib_MultiBoxPrior ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiBoxPrior(symbol)" args =>
-                                   String ->
-                                     ArgsHMap "_backward__contrib_MultiBoxPrior(symbol)" args ->
-                                       IO SymbolHandle
-_backward__contrib_MultiBoxPrior name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiProposal(symbol)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle),
-        '("bbox_pred", AttrOpt SymbolHandle),
-        '("im_info", AttrOpt SymbolHandle)]
-
-_contrib_MultiProposal ::
-                       forall args . Fullfilled "_contrib_MultiProposal(symbol)" args =>
-                         String ->
-                           ArgsHMap "_contrib_MultiProposal(symbol)" args -> IO SymbolHandle
-_contrib_MultiProposal name args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiProposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiProposal(symbol)" = '[]
-
-_backward__contrib_MultiProposal ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiProposal(symbol)" args =>
-                                   String ->
-                                     ArgsHMap "_backward__contrib_MultiProposal(symbol)" args ->
-                                       IO SymbolHandle
-_backward__contrib_MultiProposal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_PSROIPooling(symbol)" =
-     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),
-        '("pooled_size", AttrReq Int), '("group_size", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)]
-
-_contrib_PSROIPooling ::
-                      forall args . Fullfilled "_contrib_PSROIPooling(symbol)" args =>
-                        String ->
-                          ArgsHMap "_contrib_PSROIPooling(symbol)" args -> IO SymbolHandle
-_contrib_PSROIPooling name args
-  = let scalarArgs
-          = catMaybes
-              [("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe Int),
-               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_PSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_PSROIPooling(symbol)" = '[]
-
-_backward__contrib_PSROIPooling ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_PSROIPooling(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_backward__contrib_PSROIPooling(symbol)" args ->
-                                      IO SymbolHandle
-_backward__contrib_PSROIPooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_contrib_DeformableConvolution(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("num_deformable_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),
-        '("data", AttrOpt SymbolHandle), '("offset", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]
-
-_contrib_DeformableConvolution ::
-                               forall args .
-                                 Fullfilled "_contrib_DeformableConvolution(symbol)" args =>
-                                 String ->
-                                   ArgsHMap "_contrib_DeformableConvolution(symbol)" args ->
-                                     IO SymbolHandle
-_contrib_DeformableConvolution name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("num_deformable_group",) . showValue <$>
-                 (args !? #num_deformable_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("offset",) <$> (args !? #offset :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformableConvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_DeformableConvolution(symbol)" =
-     '[]
-
-_backward__contrib_DeformableConvolution ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward__contrib_DeformableConvolution(symbol)"
-                                             args =>
-                                           String ->
-                                             ArgsHMap
-                                               "_backward__contrib_DeformableConvolution(symbol)"
-                                               args
-                                               -> IO SymbolHandle
-_backward__contrib_DeformableConvolution name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_ifft(symbol)" =
-     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-_contrib_ifft ::
-              forall args . Fullfilled "_contrib_ifft(symbol)" args =>
-                String -> ArgsHMap "_contrib_ifft(symbol)" args -> IO SymbolHandle
-_contrib_ifft name args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ifft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__contrib_ifft(symbol)" = '[]
-
-_backward__contrib_ifft ::
-                        forall args . Fullfilled "_backward__contrib_ifft(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward__contrib_ifft(symbol)" args -> IO SymbolHandle
-_backward__contrib_ifft name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_ifft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_SyncBatchNorm(symbol)" = '[]
-
-_backward__contrib_SyncBatchNorm ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_SyncBatchNorm(symbol)" args =>
-                                   String ->
-                                     ArgsHMap "_backward__contrib_SyncBatchNorm(symbol)" args ->
-                                       IO SymbolHandle
-_backward__contrib_SyncBatchNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_InstanceNorm(symbol)" =
-     '[ '("eps", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]
-
-_InstanceNorm ::
-              forall args . Fullfilled "_InstanceNorm(symbol)" args =>
-                String -> ArgsHMap "_InstanceNorm(symbol)" args -> IO SymbolHandle
-_InstanceNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "InstanceNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_InstanceNorm(symbol)" = '[]
-
-_backward_InstanceNorm ::
-                       forall args . Fullfilled "_backward_InstanceNorm(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_InstanceNorm(symbol)" args -> IO SymbolHandle
-_backward_InstanceNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_InstanceNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SVMOutput(symbol)" =
-     '[ '("margin", AttrOpt Float),
-        '("regularization_coefficient", AttrOpt Float),
-        '("use_linear", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_SVMOutput ::
-           forall args . Fullfilled "_SVMOutput(symbol)" args =>
-             String -> ArgsHMap "_SVMOutput(symbol)" args -> IO SymbolHandle
-_SVMOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),
-               ("regularization_coefficient",) . showValue <$>
-                 (args !? #regularization_coefficient :: Maybe Float),
-               ("use_linear",) . showValue <$>
-                 (args !? #use_linear :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SVMOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SVMOutput(symbol)" = '[]
-
-_backward_SVMOutput ::
-                    forall args . Fullfilled "_backward_SVMOutput(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_SVMOutput(symbol)" args -> IO SymbolHandle
-_backward_SVMOutput name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SVMOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_GridGenerator(symbol)" =
-     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),
-        '("target_shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-_GridGenerator ::
-               forall args . Fullfilled "_GridGenerator(symbol)" args =>
-                 String -> ArgsHMap "_GridGenerator(symbol)" args -> IO SymbolHandle
-_GridGenerator name args
-  = let scalarArgs
-          = catMaybes
-              [("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "GridGenerator"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_GridGenerator(symbol)" = '[]
-
-_backward_GridGenerator ::
-                        forall args . Fullfilled "_backward_GridGenerator(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_GridGenerator(symbol)" args -> IO SymbolHandle
-_backward_GridGenerator name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_GridGenerator"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Pad(symbol)" = '[]
-
-_backward_Pad ::
-              forall args . Fullfilled "_backward_Pad(symbol)" args =>
-                String -> ArgsHMap "_backward_Pad(symbol)" args -> IO SymbolHandle
-_backward_Pad name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pad"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Convolution_v1(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle)]
-
-_Convolution_v1 ::
-                forall args . Fullfilled "_Convolution_v1(symbol)" args =>
-                  String ->
-                    ArgsHMap "_Convolution_v1(symbol)" args -> IO SymbolHandle
-_Convolution_v1 name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Convolution_v1(symbol)" =
-     '[]
-
-_backward_Convolution_v1 ::
-                         forall args . Fullfilled "_backward_Convolution_v1(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_Convolution_v1(symbol)" args -> IO SymbolHandle
-_backward_Convolution_v1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SequenceReverse(symbol)" =
-     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle),
-        '("sequence_length", AttrOpt SymbolHandle)]
-
-_SequenceReverse ::
-                 forall args . Fullfilled "_SequenceReverse(symbol)" args =>
-                   String ->
-                     ArgsHMap "_SequenceReverse(symbol)" args -> IO SymbolHandle
-_SequenceReverse name args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceReverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SequenceReverse(symbol)" =
-     '[]
-
-_backward_SequenceReverse ::
-                          forall args .
-                            Fullfilled "_backward_SequenceReverse(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_SequenceReverse(symbol)" args ->
-                                IO SymbolHandle
-_backward_SequenceReverse name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceReverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SoftmaxOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
-        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle)]
-
-_SoftmaxOutput ::
-               forall args . Fullfilled "_SoftmaxOutput(symbol)" args =>
-                 String -> ArgsHMap "_SoftmaxOutput(symbol)" args -> IO SymbolHandle
-_SoftmaxOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SoftmaxOutput(symbol)" = '[]
-
-_backward_SoftmaxOutput ::
-                        forall args . Fullfilled "_backward_SoftmaxOutput(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_SoftmaxOutput(symbol)" args -> IO SymbolHandle
-_backward_SoftmaxOutput name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Softmax(symbol)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
-        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_Softmax ::
-         forall args . Fullfilled "_Softmax(symbol)" args =>
-           String -> ArgsHMap "_Softmax(symbol)" args -> IO SymbolHandle
-_Softmax name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Softmax(symbol)" = '[]
-
-_backward_Softmax ::
-                  forall args . Fullfilled "_backward_Softmax(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_Softmax(symbol)" args -> IO SymbolHandle
-_backward_Softmax name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BilinearSampler(symbol)" =
-     '[ '("cudnn_off", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt SymbolHandle), '("grid", AttrOpt SymbolHandle)]
-
-_BilinearSampler ::
-                 forall args . Fullfilled "_BilinearSampler(symbol)" args =>
-                   String ->
-                     ArgsHMap "_BilinearSampler(symbol)" args -> IO SymbolHandle
-_BilinearSampler name args
-  = let scalarArgs
-          = catMaybes
-              [("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("grid",) <$> (args !? #grid :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BilinearSampler"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_BilinearSampler(symbol)" =
-     '[]
-
-_backward_BilinearSampler ::
-                          forall args .
-                            Fullfilled "_backward_BilinearSampler(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_BilinearSampler(symbol)" args ->
-                                IO SymbolHandle
-_backward_BilinearSampler name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BilinearSampler"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_LeakyReLU(symbol)" = '[]
-
-_backward_LeakyReLU ::
-                    forall args . Fullfilled "_backward_LeakyReLU(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_LeakyReLU(symbol)" args -> IO SymbolHandle
-_backward_LeakyReLU name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LeakyReLU"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Crop(symbol)" =
-     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),
-        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),
-        '("data", AttrOpt [SymbolHandle])]
-
-_Crop ::
-      forall args . Fullfilled "_Crop(symbol)" args =>
-        String -> ArgsHMap "_Crop(symbol)" args -> IO SymbolHandle
-_Crop name args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),
-               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),
-               ("center_crop",) . showValue <$>
-                 (args !? #center_crop :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "Crop"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_Crop(symbol)" = '[]
-
-_backward_Crop ::
-               forall args . Fullfilled "_backward_Crop(symbol)" args =>
-                 String -> ArgsHMap "_backward_Crop(symbol)" args -> IO SymbolHandle
-_backward_Crop name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Crop"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_ROIPooling(symbol)" =
-     '[ '("pooled_size", AttrReq [Int]),
-        '("spatial_scale", AttrReq Float), '("data", AttrOpt SymbolHandle),
-        '("rois", AttrOpt SymbolHandle)]
-
-_ROIPooling ::
-            forall args . Fullfilled "_ROIPooling(symbol)" args =>
-              String -> ArgsHMap "_ROIPooling(symbol)" args -> IO SymbolHandle
-_ROIPooling name args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_ROIPooling(symbol)" = '[]
-
-_backward_ROIPooling ::
-                     forall args . Fullfilled "_backward_ROIPooling(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_ROIPooling(symbol)" args -> IO SymbolHandle
-_backward_ROIPooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SequenceLast(symbol)" =
-     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle),
-        '("sequence_length", AttrOpt SymbolHandle)]
-
-_SequenceLast ::
-              forall args . Fullfilled "_SequenceLast(symbol)" args =>
-                String -> ArgsHMap "_SequenceLast(symbol)" args -> IO SymbolHandle
-_SequenceLast name args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceLast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SequenceLast(symbol)" = '[]
-
-_backward_SequenceLast ::
-                       forall args . Fullfilled "_backward_SequenceLast(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_SequenceLast(symbol)" args -> IO SymbolHandle
-_backward_SequenceLast name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceLast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CrossDeviceCopy(symbol)" = '[]
-
-_CrossDeviceCopy ::
-                 forall args . Fullfilled "_CrossDeviceCopy(symbol)" args =>
-                   String ->
-                     ArgsHMap "_CrossDeviceCopy(symbol)" args -> IO SymbolHandle
-_CrossDeviceCopy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CrossDeviceCopy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__CrossDeviceCopy(symbol)" =
-     '[]
-
-_backward__CrossDeviceCopy ::
-                           forall args .
-                             Fullfilled "_backward__CrossDeviceCopy(symbol)" args =>
-                             String ->
-                               ArgsHMap "_backward__CrossDeviceCopy(symbol)" args ->
-                                 IO SymbolHandle
-_backward__CrossDeviceCopy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SpatialTransformer(symbol)" =
-     '[ '("target_shape", AttrOpt [Int]),
-        '("transform_type", AttrReq (EnumType '["affine"])),
-        '("sampler_type", AttrReq (EnumType '["bilinear"])),
-        '("cudnn_off", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt SymbolHandle), '("loc", AttrOpt SymbolHandle)]
-
-_SpatialTransformer ::
-                    forall args . Fullfilled "_SpatialTransformer(symbol)" args =>
-                      String ->
-                        ArgsHMap "_SpatialTransformer(symbol)" args -> IO SymbolHandle
-_SpatialTransformer name args
-  = let scalarArgs
-          = catMaybes
-              [("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine"])),
-               ("sampler_type",) . showValue <$>
-                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"])),
-               ("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("loc",) <$> (args !? #loc :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SpatialTransformer"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SpatialTransformer(symbol)"
-     = '[]
-
-_backward_SpatialTransformer ::
-                             forall args .
-                               Fullfilled "_backward_SpatialTransformer(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_backward_SpatialTransformer(symbol)" args ->
-                                   IO SymbolHandle
-_backward_SpatialTransformer name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SpatialTransformer"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SwapAxis(symbol)" = '[]
-
-_backward_SwapAxis ::
-                   forall args . Fullfilled "_backward_SwapAxis(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_SwapAxis(symbol)" args -> IO SymbolHandle
-_backward_SwapAxis name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SwapAxis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_L2Normalization(symbol)" =
-     '[ '("eps", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_L2Normalization ::
-                 forall args . Fullfilled "_L2Normalization(symbol)" args =>
-                   String ->
-                     ArgsHMap "_L2Normalization(symbol)" args -> IO SymbolHandle
-_L2Normalization name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["channel", "instance", "spatial"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "L2Normalization"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_L2Normalization(symbol)" =
-     '[]
-
-_backward_L2Normalization ::
-                          forall args .
-                            Fullfilled "_backward_L2Normalization(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_L2Normalization(symbol)" args ->
-                                IO SymbolHandle
-_backward_L2Normalization name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_L2Normalization"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Correlation(symbol)" =
-     '[ '("kernel_size", AttrOpt Int),
-        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),
-        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),
-        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt SymbolHandle),
-        '("data2", AttrOpt SymbolHandle)]
-
-_Correlation ::
-             forall args . Fullfilled "_Correlation(symbol)" args =>
-               String -> ArgsHMap "_Correlation(symbol)" args -> IO SymbolHandle
-_Correlation name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel_size",) . showValue <$>
-                 (args !? #kernel_size :: Maybe Int),
-               ("max_displacement",) . showValue <$>
-                 (args !? #max_displacement :: Maybe Int),
-               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),
-               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),
-               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),
-               ("is_multiply",) . showValue <$>
-                 (args !? #is_multiply :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data1",) <$> (args !? #data1 :: Maybe SymbolHandle),
-               ("data2",) <$> (args !? #data2 :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Correlation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Correlation(symbol)" = '[]
-
-_backward_Correlation ::
-                      forall args . Fullfilled "_backward_Correlation(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_Correlation(symbol)" args -> IO SymbolHandle
-_backward_Correlation name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Correlation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_IdentityAttachKLSparseReg(symbol)" = '[]
-
-_backward_IdentityAttachKLSparseReg ::
-                                    forall args .
-                                      Fullfilled "_backward_IdentityAttachKLSparseReg(symbol)"
-                                        args =>
-                                      String ->
-                                        ArgsHMap "_backward_IdentityAttachKLSparseReg(symbol)" args
-                                          -> IO SymbolHandle
-_backward_IdentityAttachKLSparseReg name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_MakeLoss(symbol)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_MakeLoss ::
-          forall args . Fullfilled "_MakeLoss(symbol)" args =>
-            String -> ArgsHMap "_MakeLoss(symbol)" args -> IO SymbolHandle
-_MakeLoss name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MakeLoss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_MakeLoss(symbol)" = '[]
-
-_backward_MakeLoss ::
-                   forall args . Fullfilled "_backward_MakeLoss(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_MakeLoss(symbol)" args -> IO SymbolHandle
-_backward_MakeLoss name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MakeLoss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SliceChannel(symbol)" = '[]
-
-_backward_SliceChannel ::
-                       forall args . Fullfilled "_backward_SliceChannel(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_SliceChannel(symbol)" args -> IO SymbolHandle
-_backward_SliceChannel name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SliceChannel"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_RNN(symbol)" =
-     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),
-        '("bidirectional", AttrOpt Bool),
-        '("mode",
-          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),
-        '("projection_size", AttrOpt (Maybe Int)),
-        '("lstm_state_clip_min", AttrOpt (Maybe Double)),
-        '("lstm_state_clip_max", AttrOpt (Maybe Double)),
-        '("lstm_state_clip_nan", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle),
-        '("parameters", AttrOpt SymbolHandle),
-        '("state", AttrOpt SymbolHandle),
-        '("state_cell", AttrOpt SymbolHandle)]
-
-_RNN ::
-     forall args . Fullfilled "_RNN(symbol)" args =>
-       String -> ArgsHMap "_RNN(symbol)" args -> IO SymbolHandle
-_RNN name args
-  = let scalarArgs
-          = catMaybes
-              [("state_size",) . showValue <$>
-                 (args !? #state_size :: Maybe Int),
-               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),
-               ("bidirectional",) . showValue <$>
-                 (args !? #bidirectional :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("state_outputs",) . showValue <$>
-                 (args !? #state_outputs :: Maybe Bool),
-               ("projection_size",) . showValue <$>
-                 (args !? #projection_size :: Maybe (Maybe Int)),
-               ("lstm_state_clip_min",) . showValue <$>
-                 (args !? #lstm_state_clip_min :: Maybe (Maybe Double)),
-               ("lstm_state_clip_max",) . showValue <$>
-                 (args !? #lstm_state_clip_max :: Maybe (Maybe Double)),
-               ("lstm_state_clip_nan",) . showValue <$>
-                 (args !? #lstm_state_clip_nan :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("parameters",) <$> (args !? #parameters :: Maybe SymbolHandle),
-               ("state",) <$> (args !? #state :: Maybe SymbolHandle),
-               ("state_cell",) <$> (args !? #state_cell :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "RNN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_RNN(symbol)" = '[]
-
-_backward_RNN ::
-              forall args . Fullfilled "_backward_RNN(symbol)" args =>
-                String -> ArgsHMap "_backward_RNN(symbol)" args -> IO SymbolHandle
-_backward_RNN name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_RNN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Pooling_v1(symbol)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])),
-        '("global_pool", AttrOpt Bool),
-        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-_Pooling_v1 ::
-            forall args . Fullfilled "_Pooling_v1(symbol)" args =>
-              String -> ArgsHMap "_Pooling_v1(symbol)" args -> IO SymbolHandle
-_Pooling_v1 name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Pooling_v1(symbol)" = '[]
-
-_backward_Pooling_v1 ::
-                     forall args . Fullfilled "_backward_Pooling_v1(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_Pooling_v1(symbol)" args -> IO SymbolHandle
-_backward_Pooling_v1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_BatchNorm_v1(symbol)" = '[]
-
-_backward_BatchNorm_v1 ::
-                       forall args . Fullfilled "_backward_BatchNorm_v1(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_BatchNorm_v1(symbol)" args -> IO SymbolHandle
-_backward_BatchNorm_v1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SequenceMask(symbol)" =
-     '[ '("use_sequence_length", AttrOpt Bool),
-        '("value", AttrOpt Float), '("axis", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle),
-        '("sequence_length", AttrOpt SymbolHandle)]
-
-_SequenceMask ::
-              forall args . Fullfilled "_SequenceMask(symbol)" args =>
-                String -> ArgsHMap "_SequenceMask(symbol)" args -> IO SymbolHandle
-_SequenceMask name args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("value",) . showValue <$> (args !? #value :: Maybe Float),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceMask"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SequenceMask(symbol)" = '[]
-
-_backward_SequenceMask ::
-                       forall args . Fullfilled "_backward_SequenceMask(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_SequenceMask(symbol)" args -> IO SymbolHandle
-_backward_SequenceMask name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceMask"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_set_value(symbol)" =
-     '[ '("src", AttrOpt Float)]
-
-_set_value ::
-           forall args . Fullfilled "_set_value(symbol)" args =>
-             String -> ArgsHMap "_set_value(symbol)" args -> IO SymbolHandle
-_set_value name args
-  = let scalarArgs
-          = catMaybes
-              [("src",) . showValue <$> (args !? #src :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_set_value"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_imdecode(symbol)" =
-     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),
-        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),
-        '("c", AttrOpt Int), '("size", AttrOpt Int),
-        '("mean", AttrOpt SymbolHandle)]
-
-_imdecode ::
-          forall args . Fullfilled "_imdecode(symbol)" args =>
-            String -> ArgsHMap "_imdecode(symbol)" args -> IO SymbolHandle
-_imdecode name args
-  = let scalarArgs
-          = catMaybes
-              [("index",) . showValue <$> (args !? #index :: Maybe Int),
-               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),
-               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),
-               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),
-               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),
-               ("c",) . showValue <$> (args !? #c :: Maybe Int),
-               ("size",) . showValue <$> (args !? #size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("mean",) <$> (args !? #mean :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_imdecode"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
diff --git a/ops/1.5/MXNet/Base/Operators/NDArray.hs b/ops/1.5/MXNet/Base/Operators/NDArray.hs
deleted file mode 100644
--- a/ops/1.5/MXNet/Base/Operators/NDArray.hs
+++ /dev/null
@@ -1,23053 +0,0 @@
-module MXNet.Base.Operators.NDArray where
-import MXNet.Base.Raw
-import MXNet.Base.Spec.Operator
-import MXNet.Base.Spec.HMap
-import Data.Maybe (catMaybes, fromMaybe)
-
-type instance ParameterList "_CuDNNBatchNorm(ndarray)" =
-     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle),
-        '("moving_mean", AttrOpt NDArrayHandle),
-        '("moving_var", AttrOpt NDArrayHandle)]
-
-_CuDNNBatchNorm ::
-                forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args =>
-                  ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO [NDArrayHandle]
-_CuDNNBatchNorm args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CuDNNBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CuDNNBatchNorm_upd ::
-                    forall args . Fullfilled "_CuDNNBatchNorm(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_CuDNNBatchNorm(ndarray)" args -> IO ()
-_CuDNNBatchNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CuDNNBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_CuDNNBatchNorm(ndarray)" =
-     '[]
-
-_backward_CuDNNBatchNorm ::
-                         forall args .
-                           Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args =>
-                           ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_CuDNNBatchNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_CuDNNBatchNorm_upd ::
-                             forall args .
-                               Fullfilled "_backward_CuDNNBatchNorm(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_CuDNNBatchNorm(ndarray)" args -> IO ()
-_backward_CuDNNBatchNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_multinomial(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_sample_multinomial ::
-                    forall args . Fullfilled "_sample_multinomial(ndarray)" args =>
-                      ArgsHMap "_sample_multinomial(ndarray)" args -> IO [NDArrayHandle]
-_sample_multinomial args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_multinomial_upd ::
-                        forall args . Fullfilled "_sample_multinomial(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_sample_multinomial(ndarray)" args -> IO ()
-_sample_multinomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sample_multinomial(ndarray)"
-     = '[]
-
-_backward_sample_multinomial ::
-                             forall args .
-                               Fullfilled "_backward_sample_multinomial(ndarray)" args =>
-                               ArgsHMap "_backward_sample_multinomial(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_backward_sample_multinomial args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sample_multinomial_upd ::
-                                 forall args .
-                                   Fullfilled "_backward_sample_multinomial(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_backward_sample_multinomial(ndarray)" args -> IO ()
-_backward_sample_multinomial_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sample_multinomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_uniform(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("low", AttrOpt NDArrayHandle), '("high", AttrOpt NDArrayHandle)]
-
-_sample_uniform ::
-                forall args . Fullfilled "_sample_uniform(ndarray)" args =>
-                  ArgsHMap "_sample_uniform(ndarray)" args -> IO [NDArrayHandle]
-_sample_uniform args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("low",) <$> (args !? #low :: Maybe NDArrayHandle),
-               ("high",) <$> (args !? #high :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_uniform_upd ::
-                    forall args . Fullfilled "_sample_uniform(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_sample_uniform(ndarray)" args -> IO ()
-_sample_uniform_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("low",) <$> (args !? #low :: Maybe NDArrayHandle),
-               ("high",) <$> (args !? #high :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_normal(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt NDArrayHandle), '("sigma", AttrOpt NDArrayHandle)]
-
-_sample_normal ::
-               forall args . Fullfilled "_sample_normal(ndarray)" args =>
-                 ArgsHMap "_sample_normal(ndarray)" args -> IO [NDArrayHandle]
-_sample_normal args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_normal_upd ::
-                   forall args . Fullfilled "_sample_normal(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_sample_normal(ndarray)" args -> IO ()
-_sample_normal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("sigma",) <$> (args !? #sigma :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_gamma(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("alpha", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_sample_gamma ::
-              forall args . Fullfilled "_sample_gamma(ndarray)" args =>
-                ArgsHMap "_sample_gamma(ndarray)" args -> IO [NDArrayHandle]
-_sample_gamma args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_gamma_upd ::
-                  forall args . Fullfilled "_sample_gamma(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_sample_gamma(ndarray)" args -> IO ()
-_sample_gamma_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_exponential(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt NDArrayHandle)]
-
-_sample_exponential ::
-                    forall args . Fullfilled "_sample_exponential(ndarray)" args =>
-                      ArgsHMap "_sample_exponential(ndarray)" args -> IO [NDArrayHandle]
-_sample_exponential args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_exponential_upd ::
-                        forall args . Fullfilled "_sample_exponential(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_sample_exponential(ndarray)" args -> IO ()
-_sample_exponential_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_poisson(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt NDArrayHandle)]
-
-_sample_poisson ::
-                forall args . Fullfilled "_sample_poisson(ndarray)" args =>
-                  ArgsHMap "_sample_poisson(ndarray)" args -> IO [NDArrayHandle]
-_sample_poisson args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_poisson_upd ::
-                    forall args . Fullfilled "_sample_poisson(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_sample_poisson(ndarray)" args -> IO ()
-_sample_poisson_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_negative_binomial(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("k", AttrOpt NDArrayHandle), '("p", AttrOpt NDArrayHandle)]
-
-_sample_negative_binomial ::
-                          forall args .
-                            Fullfilled "_sample_negative_binomial(ndarray)" args =>
-                            ArgsHMap "_sample_negative_binomial(ndarray)" args ->
-                              IO [NDArrayHandle]
-_sample_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("k",) <$> (args !? #k :: Maybe NDArrayHandle),
-               ("p",) <$> (args !? #p :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_negative_binomial_upd ::
-                              forall args .
-                                Fullfilled "_sample_negative_binomial(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_sample_negative_binomial(ndarray)" args -> IO ()
-_sample_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("k",) <$> (args !? #k :: Maybe NDArrayHandle),
-               ("p",) <$> (args !? #p :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_sample_generalized_negative_binomial(ndarray)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt NDArrayHandle), '("alpha", AttrOpt NDArrayHandle)]
-
-_sample_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_sample_generalized_negative_binomial(ndarray)"
-                                          args =>
-                                        ArgsHMap "_sample_generalized_negative_binomial(ndarray)"
-                                          args
-                                          -> IO [NDArrayHandle]
-_sample_generalized_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_generalized_negative_binomial_upd ::
-                                          forall args .
-                                            Fullfilled
-                                              "_sample_generalized_negative_binomial(ndarray)"
-                                              args =>
-                                            [NDArrayHandle] ->
-                                              ArgsHMap
-                                                "_sample_generalized_negative_binomial(ndarray)"
-                                                args
-                                                -> IO ()
-_sample_generalized_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe NDArrayHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sample_unique_zipfian(ndarray)" =
-     '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])]
-
-_sample_unique_zipfian ::
-                       forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args =>
-                         ArgsHMap "_sample_unique_zipfian(ndarray)" args ->
-                           IO [NDArrayHandle]
-_sample_unique_zipfian args
-  = let scalarArgs
-          = catMaybes
-              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_unique_zipfian"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sample_unique_zipfian_upd ::
-                           forall args . Fullfilled "_sample_unique_zipfian(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_sample_unique_zipfian(ndarray)" args -> IO ()
-_sample_unique_zipfian_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_unique_zipfian"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_uniform(ndarray)" =
-     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_uniform ::
-                forall args . Fullfilled "_random_uniform(ndarray)" args =>
-                  ArgsHMap "_random_uniform(ndarray)" args -> IO [NDArrayHandle]
-_random_uniform args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_uniform_upd ::
-                    forall args . Fullfilled "_random_uniform(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_random_uniform(ndarray)" args -> IO ()
-_random_uniform_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_normal(ndarray)" =
-     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_normal ::
-               forall args . Fullfilled "_random_normal(ndarray)" args =>
-                 ArgsHMap "_random_normal(ndarray)" args -> IO [NDArrayHandle]
-_random_normal args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_normal_upd ::
-                   forall args . Fullfilled "_random_normal(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_random_normal(ndarray)" args -> IO ()
-_random_normal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_gamma(ndarray)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_gamma ::
-              forall args . Fullfilled "_random_gamma(ndarray)" args =>
-                ArgsHMap "_random_gamma(ndarray)" args -> IO [NDArrayHandle]
-_random_gamma args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_gamma_upd ::
-                  forall args . Fullfilled "_random_gamma(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_random_gamma(ndarray)" args -> IO ()
-_random_gamma_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_exponential(ndarray)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_exponential ::
-                    forall args . Fullfilled "_random_exponential(ndarray)" args =>
-                      ArgsHMap "_random_exponential(ndarray)" args -> IO [NDArrayHandle]
-_random_exponential args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_exponential_upd ::
-                        forall args . Fullfilled "_random_exponential(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_random_exponential(ndarray)" args -> IO ()
-_random_exponential_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_poisson(ndarray)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_poisson ::
-                forall args . Fullfilled "_random_poisson(ndarray)" args =>
-                  ArgsHMap "_random_poisson(ndarray)" args -> IO [NDArrayHandle]
-_random_poisson args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_poisson_upd ::
-                    forall args . Fullfilled "_random_poisson(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_random_poisson(ndarray)" args -> IO ()
-_random_poisson_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_negative_binomial(ndarray)" =
-     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_negative_binomial ::
-                          forall args .
-                            Fullfilled "_random_negative_binomial(ndarray)" args =>
-                            ArgsHMap "_random_negative_binomial(ndarray)" args ->
-                              IO [NDArrayHandle]
-_random_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_negative_binomial_upd ::
-                              forall args .
-                                Fullfilled "_random_negative_binomial(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_random_negative_binomial(ndarray)" args -> IO ()
-_random_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_random_generalized_negative_binomial(ndarray)" =
-     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_random_generalized_negative_binomial(ndarray)"
-                                          args =>
-                                        ArgsHMap "_random_generalized_negative_binomial(ndarray)"
-                                          args
-                                          -> IO [NDArrayHandle]
-_random_generalized_negative_binomial args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_generalized_negative_binomial_upd ::
-                                          forall args .
-                                            Fullfilled
-                                              "_random_generalized_negative_binomial(ndarray)"
-                                              args =>
-                                            [NDArrayHandle] ->
-                                              ArgsHMap
-                                                "_random_generalized_negative_binomial(ndarray)"
-                                                args
-                                                -> IO ()
-_random_generalized_negative_binomial_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_randint(ndarray)" =
-     '[ '("low", AttrReq Int), '("high", AttrReq Int),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype", AttrOpt (EnumType '["None", "int32", "int64"]))]
-
-_random_randint ::
-                forall args . Fullfilled "_random_randint(ndarray)" args =>
-                  ArgsHMap "_random_randint(ndarray)" args -> IO [NDArrayHandle]
-_random_randint args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Int),
-               ("high",) . showValue <$> (args !? #high :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_randint"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_randint_upd ::
-                    forall args . Fullfilled "_random_randint(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_random_randint(ndarray)" args -> IO ()
-_random_randint_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Int),
-               ("high",) . showValue <$> (args !? #high :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_randint"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_uniform_like(ndarray)" =
-     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_random_uniform_like ::
-                     forall args . Fullfilled "_random_uniform_like(ndarray)" args =>
-                       ArgsHMap "_random_uniform_like(ndarray)" args -> IO [NDArrayHandle]
-_random_uniform_like args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_uniform_like_upd ::
-                         forall args . Fullfilled "_random_uniform_like(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_random_uniform_like(ndarray)" args -> IO ()
-_random_uniform_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_normal_like(ndarray)" =
-     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_random_normal_like ::
-                    forall args . Fullfilled "_random_normal_like(ndarray)" args =>
-                      ArgsHMap "_random_normal_like(ndarray)" args -> IO [NDArrayHandle]
-_random_normal_like args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_normal_like_upd ::
-                        forall args . Fullfilled "_random_normal_like(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_random_normal_like(ndarray)" args -> IO ()
-_random_normal_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_gamma_like(ndarray)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_random_gamma_like ::
-                   forall args . Fullfilled "_random_gamma_like(ndarray)" args =>
-                     ArgsHMap "_random_gamma_like(ndarray)" args -> IO [NDArrayHandle]
-_random_gamma_like args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_gamma_like_upd ::
-                       forall args . Fullfilled "_random_gamma_like(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_random_gamma_like(ndarray)" args -> IO ()
-_random_gamma_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_exponential_like(ndarray)" =
-     '[ '("lam", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_random_exponential_like ::
-                         forall args .
-                           Fullfilled "_random_exponential_like(ndarray)" args =>
-                           ArgsHMap "_random_exponential_like(ndarray)" args ->
-                             IO [NDArrayHandle]
-_random_exponential_like args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_exponential_like_upd ::
-                             forall args .
-                               Fullfilled "_random_exponential_like(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_random_exponential_like(ndarray)" args -> IO ()
-_random_exponential_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_random_poisson_like(ndarray)" =
-     '[ '("lam", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_random_poisson_like ::
-                     forall args . Fullfilled "_random_poisson_like(ndarray)" args =>
-                       ArgsHMap "_random_poisson_like(ndarray)" args -> IO [NDArrayHandle]
-_random_poisson_like args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_poisson_like_upd ::
-                         forall args . Fullfilled "_random_poisson_like(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_random_poisson_like(ndarray)" args -> IO ()
-_random_poisson_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_random_negative_binomial_like(ndarray)" =
-     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_random_negative_binomial_like ::
-                               forall args .
-                                 Fullfilled "_random_negative_binomial_like(ndarray)" args =>
-                                 ArgsHMap "_random_negative_binomial_like(ndarray)" args ->
-                                   IO [NDArrayHandle]
-_random_negative_binomial_like args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_negative_binomial_like_upd ::
-                                   forall args .
-                                     Fullfilled "_random_negative_binomial_like(ndarray)" args =>
-                                     [NDArrayHandle] ->
-                                       ArgsHMap "_random_negative_binomial_like(ndarray)" args ->
-                                         IO ()
-_random_negative_binomial_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_random_generalized_negative_binomial_like(ndarray)"
-     =
-     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_random_generalized_negative_binomial_like ::
-                                           forall args .
-                                             Fullfilled
-                                               "_random_generalized_negative_binomial_like(ndarray)"
-                                               args =>
-                                             ArgsHMap
-                                               "_random_generalized_negative_binomial_like(ndarray)"
-                                               args
-                                               -> IO [NDArrayHandle]
-_random_generalized_negative_binomial_like args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_random_generalized_negative_binomial_like_upd ::
-                                               forall args .
-                                                 Fullfilled
-                                                   "_random_generalized_negative_binomial_like(ndarray)"
-                                                   args =>
-                                                 [NDArrayHandle] ->
-                                                   ArgsHMap
-                                                     "_random_generalized_negative_binomial_like(ndarray)"
-                                                     args
-                                                     -> IO ()
-_random_generalized_negative_binomial_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_shuffle(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_shuffle ::
-         forall args . Fullfilled "_shuffle(ndarray)" args =>
-           ArgsHMap "_shuffle(ndarray)" args -> IO [NDArrayHandle]
-_shuffle args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_shuffle"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_shuffle_upd ::
-             forall args . Fullfilled "_shuffle(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_shuffle(ndarray)" args -> IO ()
-_shuffle_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_shuffle"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Custom(ndarray)" = '[]
-
-_backward_Custom ::
-                 forall args . Fullfilled "_backward_Custom(ndarray)" args =>
-                   ArgsHMap "_backward_Custom(ndarray)" args -> IO [NDArrayHandle]
-_backward_Custom args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Custom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Custom_upd ::
-                     forall args . Fullfilled "_backward_Custom(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_Custom(ndarray)" args -> IO ()
-_backward_Custom_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Custom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_power(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_power ::
-                forall args . Fullfilled "broadcast_power(ndarray)" args =>
-                  ArgsHMap "broadcast_power(ndarray)" args -> IO [NDArrayHandle]
-broadcast_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_power_upd ::
-                    forall args . Fullfilled "broadcast_power(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "broadcast_power(ndarray)" args -> IO ()
-broadcast_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_power(ndarray)" =
-     '[]
-
-_backward_broadcast_power ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_power(ndarray)" args =>
-                            ArgsHMap "_backward_broadcast_power(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_broadcast_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_power_upd ::
-                              forall args .
-                                Fullfilled "_backward_broadcast_power(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_broadcast_power(ndarray)" args -> IO ()
-_backward_broadcast_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_maximum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_maximum ::
-                  forall args . Fullfilled "broadcast_maximum(ndarray)" args =>
-                    ArgsHMap "broadcast_maximum(ndarray)" args -> IO [NDArrayHandle]
-broadcast_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_maximum_upd ::
-                      forall args . Fullfilled "broadcast_maximum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "broadcast_maximum(ndarray)" args -> IO ()
-broadcast_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_maximum(ndarray)"
-     = '[]
-
-_backward_broadcast_maximum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_maximum(ndarray)" args =>
-                              ArgsHMap "_backward_broadcast_maximum(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_broadcast_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_maximum_upd ::
-                                forall args .
-                                  Fullfilled "_backward_broadcast_maximum(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_broadcast_maximum(ndarray)" args -> IO ()
-_backward_broadcast_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_minimum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_minimum ::
-                  forall args . Fullfilled "broadcast_minimum(ndarray)" args =>
-                    ArgsHMap "broadcast_minimum(ndarray)" args -> IO [NDArrayHandle]
-broadcast_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_minimum_upd ::
-                      forall args . Fullfilled "broadcast_minimum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "broadcast_minimum(ndarray)" args -> IO ()
-broadcast_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_minimum(ndarray)"
-     = '[]
-
-_backward_broadcast_minimum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_minimum(ndarray)" args =>
-                              ArgsHMap "_backward_broadcast_minimum(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_broadcast_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_minimum_upd ::
-                                forall args .
-                                  Fullfilled "_backward_broadcast_minimum(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_broadcast_minimum(ndarray)" args -> IO ()
-_backward_broadcast_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_hypot(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_hypot ::
-                forall args . Fullfilled "broadcast_hypot(ndarray)" args =>
-                  ArgsHMap "broadcast_hypot(ndarray)" args -> IO [NDArrayHandle]
-broadcast_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_hypot_upd ::
-                    forall args . Fullfilled "broadcast_hypot(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "broadcast_hypot(ndarray)" args -> IO ()
-broadcast_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_hypot(ndarray)" =
-     '[]
-
-_backward_broadcast_hypot ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_hypot(ndarray)" args =>
-                            ArgsHMap "_backward_broadcast_hypot(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_broadcast_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_hypot_upd ::
-                              forall args .
-                                Fullfilled "_backward_broadcast_hypot(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_broadcast_hypot(ndarray)" args -> IO ()
-_backward_broadcast_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_equal ::
-       forall args . Fullfilled "_equal(ndarray)" args =>
-         ArgsHMap "_equal(ndarray)" args -> IO [NDArrayHandle]
-_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_equal_upd ::
-           forall args . Fullfilled "_equal(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_equal(ndarray)" args -> IO ()
-_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_not_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_not_equal ::
-           forall args . Fullfilled "_not_equal(ndarray)" args =>
-             ArgsHMap "_not_equal(ndarray)" args -> IO [NDArrayHandle]
-_not_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_not_equal_upd ::
-               forall args . Fullfilled "_not_equal(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_not_equal(ndarray)" args -> IO ()
-_not_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_greater ::
-         forall args . Fullfilled "_greater(ndarray)" args =>
-           ArgsHMap "_greater(ndarray)" args -> IO [NDArrayHandle]
-_greater args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_upd ::
-             forall args . Fullfilled "_greater(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_greater(ndarray)" args -> IO ()
-_greater_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_greater_equal ::
-               forall args . Fullfilled "_greater_equal(ndarray)" args =>
-                 ArgsHMap "_greater_equal(ndarray)" args -> IO [NDArrayHandle]
-_greater_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_equal_upd ::
-                   forall args . Fullfilled "_greater_equal(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_greater_equal(ndarray)" args -> IO ()
-_greater_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_lesser ::
-        forall args . Fullfilled "_lesser(ndarray)" args =>
-          ArgsHMap "_lesser(ndarray)" args -> IO [NDArrayHandle]
-_lesser args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_upd ::
-            forall args . Fullfilled "_lesser(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_lesser(ndarray)" args -> IO ()
-_lesser_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_lesser_equal ::
-              forall args . Fullfilled "_lesser_equal(ndarray)" args =>
-                ArgsHMap "_lesser_equal(ndarray)" args -> IO [NDArrayHandle]
-_lesser_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_equal_upd ::
-                  forall args . Fullfilled "_lesser_equal(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_lesser_equal(ndarray)" args -> IO ()
-_lesser_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_and(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_logical_and ::
-             forall args . Fullfilled "_logical_and(ndarray)" args =>
-               ArgsHMap "_logical_and(ndarray)" args -> IO [NDArrayHandle]
-_logical_and args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_and_upd ::
-                 forall args . Fullfilled "_logical_and(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_logical_and(ndarray)" args -> IO ()
-_logical_and_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_or(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_logical_or ::
-            forall args . Fullfilled "_logical_or(ndarray)" args =>
-              ArgsHMap "_logical_or(ndarray)" args -> IO [NDArrayHandle]
-_logical_or args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_or_upd ::
-                forall args . Fullfilled "_logical_or(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_logical_or(ndarray)" args -> IO ()
-_logical_or_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_xor(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_logical_xor ::
-             forall args . Fullfilled "_logical_xor(ndarray)" args =>
-               ArgsHMap "_logical_xor(ndarray)" args -> IO [NDArrayHandle]
-_logical_xor args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_xor_upd ::
-                 forall args . Fullfilled "_logical_xor(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_logical_xor(ndarray)" args -> IO ()
-_logical_xor_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_power(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_power ::
-       forall args . Fullfilled "_power(ndarray)" args =>
-         ArgsHMap "_power(ndarray)" args -> IO [NDArrayHandle]
-_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_power_upd ::
-           forall args . Fullfilled "_power(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_power(ndarray)" args -> IO ()
-_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_power(ndarray)" = '[]
-
-_backward_power ::
-                forall args . Fullfilled "_backward_power(ndarray)" args =>
-                  ArgsHMap "_backward_power(ndarray)" args -> IO [NDArrayHandle]
-_backward_power args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_power_upd ::
-                    forall args . Fullfilled "_backward_power(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_power(ndarray)" args -> IO ()
-_backward_power_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_maximum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_maximum ::
-         forall args . Fullfilled "_maximum(ndarray)" args =>
-           ArgsHMap "_maximum(ndarray)" args -> IO [NDArrayHandle]
-_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_maximum_upd ::
-             forall args . Fullfilled "_maximum(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_maximum(ndarray)" args -> IO ()
-_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_maximum(ndarray)" = '[]
-
-_backward_maximum ::
-                  forall args . Fullfilled "_backward_maximum(ndarray)" args =>
-                    ArgsHMap "_backward_maximum(ndarray)" args -> IO [NDArrayHandle]
-_backward_maximum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_maximum_upd ::
-                      forall args . Fullfilled "_backward_maximum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_maximum(ndarray)" args -> IO ()
-_backward_maximum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_minimum(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_minimum ::
-         forall args . Fullfilled "_minimum(ndarray)" args =>
-           ArgsHMap "_minimum(ndarray)" args -> IO [NDArrayHandle]
-_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_minimum_upd ::
-             forall args . Fullfilled "_minimum(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_minimum(ndarray)" args -> IO ()
-_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_minimum(ndarray)" = '[]
-
-_backward_minimum ::
-                  forall args . Fullfilled "_backward_minimum(ndarray)" args =>
-                    ArgsHMap "_backward_minimum(ndarray)" args -> IO [NDArrayHandle]
-_backward_minimum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_minimum_upd ::
-                      forall args . Fullfilled "_backward_minimum(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_minimum(ndarray)" args -> IO ()
-_backward_minimum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_hypot(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_hypot ::
-       forall args . Fullfilled "_hypot(ndarray)" args =>
-         ArgsHMap "_hypot(ndarray)" args -> IO [NDArrayHandle]
-_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_hypot_upd ::
-           forall args . Fullfilled "_hypot(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_hypot(ndarray)" args -> IO ()
-_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_hypot(ndarray)" = '[]
-
-_backward_hypot ::
-                forall args . Fullfilled "_backward_hypot(ndarray)" args =>
-                  ArgsHMap "_backward_hypot(ndarray)" args -> IO [NDArrayHandle]
-_backward_hypot args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_hypot_upd ::
-                    forall args . Fullfilled "_backward_hypot(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_hypot(ndarray)" args -> IO ()
-_backward_hypot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_square_sum(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-_square_sum ::
-            forall args . Fullfilled "_square_sum(ndarray)" args =>
-              ArgsHMap "_square_sum(ndarray)" args -> IO [NDArrayHandle]
-_square_sum args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_square_sum_upd ::
-                forall args . Fullfilled "_square_sum(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_square_sum(ndarray)" args -> IO ()
-_square_sum_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_square_sum(ndarray)" = '[]
-
-_backward_square_sum ::
-                     forall args . Fullfilled "_backward_square_sum(ndarray)" args =>
-                       ArgsHMap "_backward_square_sum(ndarray)" args -> IO [NDArrayHandle]
-_backward_square_sum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_square_sum_upd ::
-                         forall args . Fullfilled "_backward_square_sum(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_square_sum(ndarray)" args -> IO ()
-_backward_square_sum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "add_n(ndarray)" =
-     '[ '("args", AttrOpt [NDArrayHandle])]
-
-add_n ::
-      forall args . Fullfilled "add_n(ndarray)" args =>
-        ArgsHMap "add_n(ndarray)" args -> IO [NDArrayHandle]
-add_n args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "add_n"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-add_n_upd ::
-          forall args . Fullfilled "add_n(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "add_n(ndarray)" args -> IO ()
-add_n_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "add_n"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_zeros_without_dtype(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype", AttrOpt Int)]
-
-_zeros_without_dtype ::
-                     forall args . Fullfilled "_zeros_without_dtype(ndarray)" args =>
-                       ArgsHMap "_zeros_without_dtype(ndarray)" args -> IO [NDArrayHandle]
-_zeros_without_dtype args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros_without_dtype"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_zeros_without_dtype_upd ::
-                         forall args . Fullfilled "_zeros_without_dtype(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_zeros_without_dtype(ndarray)" args -> IO ()
-_zeros_without_dtype_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros_without_dtype"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_zeros(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_zeros ::
-       forall args . Fullfilled "_zeros(ndarray)" args =>
-         ArgsHMap "_zeros(ndarray)" args -> IO [NDArrayHandle]
-_zeros args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_zeros_upd ::
-           forall args . Fullfilled "_zeros(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_zeros(ndarray)" args -> IO ()
-_zeros_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_eye(ndarray)" =
-     '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_eye ::
-     forall args . Fullfilled "_eye(ndarray)" args =>
-       ArgsHMap "_eye(ndarray)" args -> IO [NDArrayHandle]
-_eye args
-  = let scalarArgs
-          = catMaybes
-              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),
-               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_eye"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_eye_upd ::
-         forall args . Fullfilled "_eye(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_eye(ndarray)" args -> IO ()
-_eye_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),
-               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_eye"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_ones(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_ones ::
-      forall args . Fullfilled "_ones(ndarray)" args =>
-        ArgsHMap "_ones(ndarray)" args -> IO [NDArrayHandle]
-_ones args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ones"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_ones_upd ::
-          forall args . Fullfilled "_ones(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_ones(ndarray)" args -> IO ()
-_ones_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ones"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_full(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("value", AttrReq Double)]
-
-_full ::
-      forall args . Fullfilled "_full(ndarray)" args =>
-        ArgsHMap "_full(ndarray)" args -> IO [NDArrayHandle]
-_full args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_full"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_full_upd ::
-          forall args . Fullfilled "_full(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_full(ndarray)" args -> IO ()
-_full_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_full"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_arange(ndarray)" =
-     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),
-        '("step", AttrOpt Double), '("repeat", AttrOpt Int),
-        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_arange ::
-        forall args . Fullfilled "_arange(ndarray)" args =>
-          ArgsHMap "_arange(ndarray)" args -> IO [NDArrayHandle]
-_arange args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("infer_range",) . showValue <$>
-                 (args !? #infer_range :: Maybe Bool),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_arange"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_arange_upd ::
-            forall args . Fullfilled "_arange(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_arange(ndarray)" args -> IO ()
-_arange_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("infer_range",) . showValue <$>
-                 (args !? #infer_range :: Maybe Bool),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_arange"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linspace(ndarray)" =
-     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),
-        '("step", AttrOpt Double), '("repeat", AttrOpt Int),
-        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_linspace ::
-          forall args . Fullfilled "_linspace(ndarray)" args =>
-            ArgsHMap "_linspace(ndarray)" args -> IO [NDArrayHandle]
-_linspace args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("infer_range",) . showValue <$>
-                 (args !? #infer_range :: Maybe Bool),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linspace"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linspace_upd ::
-              forall args . Fullfilled "_linspace(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_linspace(ndarray)" args -> IO ()
-_linspace_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("infer_range",) . showValue <$>
-                 (args !? #infer_range :: Maybe Bool),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linspace"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "zeros_like(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-zeros_like ::
-           forall args . Fullfilled "zeros_like(ndarray)" args =>
-             ArgsHMap "zeros_like(ndarray)" args -> IO [NDArrayHandle]
-zeros_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "zeros_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-zeros_like_upd ::
-               forall args . Fullfilled "zeros_like(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "zeros_like(ndarray)" args -> IO ()
-zeros_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "zeros_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ones_like(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-ones_like ::
-          forall args . Fullfilled "ones_like(ndarray)" args =>
-            ArgsHMap "ones_like(ndarray)" args -> IO [NDArrayHandle]
-ones_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ones_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ones_like_upd ::
-              forall args . Fullfilled "ones_like(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "ones_like(ndarray)" args -> IO ()
-ones_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ones_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_add(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_add ::
-              forall args . Fullfilled "broadcast_add(ndarray)" args =>
-                ArgsHMap "broadcast_add(ndarray)" args -> IO [NDArrayHandle]
-broadcast_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_add_upd ::
-                  forall args . Fullfilled "broadcast_add(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_add(ndarray)" args -> IO ()
-broadcast_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_add(ndarray)" =
-     '[]
-
-_backward_broadcast_add ::
-                        forall args . Fullfilled "_backward_broadcast_add(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_add(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_add_upd ::
-                            forall args . Fullfilled "_backward_broadcast_add(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_add(ndarray)" args -> IO ()
-_backward_broadcast_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_sub(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_sub ::
-              forall args . Fullfilled "broadcast_sub(ndarray)" args =>
-                ArgsHMap "broadcast_sub(ndarray)" args -> IO [NDArrayHandle]
-broadcast_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_sub_upd ::
-                  forall args . Fullfilled "broadcast_sub(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_sub(ndarray)" args -> IO ()
-broadcast_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_sub(ndarray)" =
-     '[]
-
-_backward_broadcast_sub ::
-                        forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_sub(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_sub_upd ::
-                            forall args . Fullfilled "_backward_broadcast_sub(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_sub(ndarray)" args -> IO ()
-_backward_broadcast_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_mul(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_mul ::
-              forall args . Fullfilled "broadcast_mul(ndarray)" args =>
-                ArgsHMap "broadcast_mul(ndarray)" args -> IO [NDArrayHandle]
-broadcast_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_mul_upd ::
-                  forall args . Fullfilled "broadcast_mul(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_mul(ndarray)" args -> IO ()
-broadcast_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_mul(ndarray)" =
-     '[]
-
-_backward_broadcast_mul ::
-                        forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_mul(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_mul_upd ::
-                            forall args . Fullfilled "_backward_broadcast_mul(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_mul(ndarray)" args -> IO ()
-_backward_broadcast_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_div(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_div ::
-              forall args . Fullfilled "broadcast_div(ndarray)" args =>
-                ArgsHMap "broadcast_div(ndarray)" args -> IO [NDArrayHandle]
-broadcast_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_div_upd ::
-                  forall args . Fullfilled "broadcast_div(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_div(ndarray)" args -> IO ()
-broadcast_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_div(ndarray)" =
-     '[]
-
-_backward_broadcast_div ::
-                        forall args . Fullfilled "_backward_broadcast_div(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_div(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_div_upd ::
-                            forall args . Fullfilled "_backward_broadcast_div(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_div(ndarray)" args -> IO ()
-_backward_broadcast_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_mod(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_mod ::
-              forall args . Fullfilled "broadcast_mod(ndarray)" args =>
-                ArgsHMap "broadcast_mod(ndarray)" args -> IO [NDArrayHandle]
-broadcast_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_mod_upd ::
-                  forall args . Fullfilled "broadcast_mod(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "broadcast_mod(ndarray)" args -> IO ()
-broadcast_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_broadcast_mod(ndarray)" =
-     '[]
-
-_backward_broadcast_mod ::
-                        forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args =>
-                          ArgsHMap "_backward_broadcast_mod(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_broadcast_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_broadcast_mod_upd ::
-                            forall args . Fullfilled "_backward_broadcast_mod(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_broadcast_mod(ndarray)" args -> IO ()
-_backward_broadcast_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_gemm(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),
-        '("axis", AttrOpt Int), '("_A", AttrOpt NDArrayHandle),
-        '("_B", AttrOpt NDArrayHandle), '("_C", AttrOpt NDArrayHandle)]
-
-_linalg_gemm ::
-             forall args . Fullfilled "_linalg_gemm(ndarray)" args =>
-               ArgsHMap "_linalg_gemm(ndarray)" args -> IO [NDArrayHandle]
-_linalg_gemm args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle),
-               ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_gemm_upd ::
-                 forall args . Fullfilled "_linalg_gemm(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_gemm(ndarray)" args -> IO ()
-_linalg_gemm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle),
-               ("_C",) <$> (args !? #_C :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_gemm(ndarray)" = '[]
-
-_backward_linalg_gemm ::
-                      forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_gemm(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_gemm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_gemm_upd ::
-                          forall args . Fullfilled "_backward_linalg_gemm(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_gemm(ndarray)" args -> IO ()
-_backward_linalg_gemm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_gemm2(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("axis", AttrOpt Int),
-        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)]
-
-_linalg_gemm2 ::
-              forall args . Fullfilled "_linalg_gemm2(ndarray)" args =>
-                ArgsHMap "_linalg_gemm2(ndarray)" args -> IO [NDArrayHandle]
-_linalg_gemm2 args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_gemm2_upd ::
-                  forall args . Fullfilled "_linalg_gemm2(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_gemm2(ndarray)" args -> IO ()
-_linalg_gemm2_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_gemm2(ndarray)" = '[]
-
-_backward_linalg_gemm2 ::
-                       forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_gemm2(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_gemm2 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_gemm2_upd ::
-                           forall args . Fullfilled "_backward_linalg_gemm2(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_gemm2(ndarray)" args -> IO ()
-_backward_linalg_gemm2_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_potrf(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_potrf ::
-              forall args . Fullfilled "_linalg_potrf(ndarray)" args =>
-                ArgsHMap "_linalg_potrf(ndarray)" args -> IO [NDArrayHandle]
-_linalg_potrf args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_potrf_upd ::
-                  forall args . Fullfilled "_linalg_potrf(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_potrf(ndarray)" args -> IO ()
-_linalg_potrf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_potrf(ndarray)" = '[]
-
-_backward_linalg_potrf ::
-                       forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_potrf(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_potrf args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_potrf_upd ::
-                           forall args . Fullfilled "_backward_linalg_potrf(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_potrf(ndarray)" args -> IO ()
-_backward_linalg_potrf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potrf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_potri(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_potri ::
-              forall args . Fullfilled "_linalg_potri(ndarray)" args =>
-                ArgsHMap "_linalg_potri(ndarray)" args -> IO [NDArrayHandle]
-_linalg_potri args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_potri_upd ::
-                  forall args . Fullfilled "_linalg_potri(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_potri(ndarray)" args -> IO ()
-_linalg_potri_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_potri(ndarray)" = '[]
-
-_backward_linalg_potri ::
-                       forall args . Fullfilled "_backward_linalg_potri(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_potri(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_potri args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_potri_upd ::
-                           forall args . Fullfilled "_backward_linalg_potri(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_potri(ndarray)" args -> IO ()
-_backward_linalg_potri_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potri"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_trmm(ndarray)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)]
-
-_linalg_trmm ::
-             forall args . Fullfilled "_linalg_trmm(ndarray)" args =>
-               ArgsHMap "_linalg_trmm(ndarray)" args -> IO [NDArrayHandle]
-_linalg_trmm args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_trmm_upd ::
-                 forall args . Fullfilled "_linalg_trmm(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_trmm(ndarray)" args -> IO ()
-_linalg_trmm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_trmm(ndarray)" = '[]
-
-_backward_linalg_trmm ::
-                      forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_trmm(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_trmm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_trmm_upd ::
-                          forall args . Fullfilled "_backward_linalg_trmm(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_trmm(ndarray)" args -> IO ()
-_backward_linalg_trmm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trmm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_trsm(ndarray)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt NDArrayHandle), '("_B", AttrOpt NDArrayHandle)]
-
-_linalg_trsm ::
-             forall args . Fullfilled "_linalg_trsm(ndarray)" args =>
-               ArgsHMap "_linalg_trsm(ndarray)" args -> IO [NDArrayHandle]
-_linalg_trsm args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_trsm_upd ::
-                 forall args . Fullfilled "_linalg_trsm(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_trsm(ndarray)" args -> IO ()
-_linalg_trsm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle),
-               ("_B",) <$> (args !? #_B :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_trsm(ndarray)" = '[]
-
-_backward_linalg_trsm ::
-                      forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_trsm(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_trsm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_trsm_upd ::
-                          forall args . Fullfilled "_backward_linalg_trsm(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_trsm(ndarray)" args -> IO ()
-_backward_linalg_trsm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trsm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_sumlogdiag(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_sumlogdiag ::
-                   forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args =>
-                     ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO [NDArrayHandle]
-_linalg_sumlogdiag args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_sumlogdiag_upd ::
-                       forall args . Fullfilled "_linalg_sumlogdiag(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_linalg_sumlogdiag(ndarray)" args -> IO ()
-_linalg_sumlogdiag_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_sumlogdiag(ndarray)"
-     = '[]
-
-_backward_linalg_sumlogdiag ::
-                            forall args .
-                              Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args =>
-                              ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_linalg_sumlogdiag args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_sumlogdiag_upd ::
-                                forall args .
-                                  Fullfilled "_backward_linalg_sumlogdiag(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_linalg_sumlogdiag(ndarray)" args -> IO ()
-_backward_linalg_sumlogdiag_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_extractdiag(ndarray)" =
-     '[ '("offset", AttrOpt Int), '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_extractdiag ::
-                    forall args . Fullfilled "_linalg_extractdiag(ndarray)" args =>
-                      ArgsHMap "_linalg_extractdiag(ndarray)" args -> IO [NDArrayHandle]
-_linalg_extractdiag args
-  = let scalarArgs
-          = catMaybes
-              [("offset",) . showValue <$> (args !? #offset :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_extractdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_extractdiag_upd ::
-                        forall args . Fullfilled "_linalg_extractdiag(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_linalg_extractdiag(ndarray)" args -> IO ()
-_linalg_extractdiag_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("offset",) . showValue <$> (args !? #offset :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_extractdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_extractdiag(ndarray)"
-     = '[]
-
-_backward_linalg_extractdiag ::
-                             forall args .
-                               Fullfilled "_backward_linalg_extractdiag(ndarray)" args =>
-                               ArgsHMap "_backward_linalg_extractdiag(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_backward_linalg_extractdiag args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_extractdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_extractdiag_upd ::
-                                 forall args .
-                                   Fullfilled "_backward_linalg_extractdiag(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_backward_linalg_extractdiag(ndarray)" args -> IO ()
-_backward_linalg_extractdiag_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_extractdiag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_makediag(ndarray)" =
-     '[ '("offset", AttrOpt Int), '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_makediag ::
-                 forall args . Fullfilled "_linalg_makediag(ndarray)" args =>
-                   ArgsHMap "_linalg_makediag(ndarray)" args -> IO [NDArrayHandle]
-_linalg_makediag args
-  = let scalarArgs
-          = catMaybes
-              [("offset",) . showValue <$> (args !? #offset :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_makediag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_makediag_upd ::
-                     forall args . Fullfilled "_linalg_makediag(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_linalg_makediag(ndarray)" args -> IO ()
-_linalg_makediag_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("offset",) . showValue <$> (args !? #offset :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_makediag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_makediag(ndarray)" =
-     '[]
-
-_backward_linalg_makediag ::
-                          forall args .
-                            Fullfilled "_backward_linalg_makediag(ndarray)" args =>
-                            ArgsHMap "_backward_linalg_makediag(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_linalg_makediag args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_makediag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_makediag_upd ::
-                              forall args .
-                                Fullfilled "_backward_linalg_makediag(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_linalg_makediag(ndarray)" args -> IO ()
-_backward_linalg_makediag_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_makediag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_extracttrian(ndarray)" =
-     '[ '("offset", AttrOpt Int), '("lower", AttrOpt Bool),
-        '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_extracttrian ::
-                     forall args . Fullfilled "_linalg_extracttrian(ndarray)" args =>
-                       ArgsHMap "_linalg_extracttrian(ndarray)" args -> IO [NDArrayHandle]
-_linalg_extracttrian args
-  = let scalarArgs
-          = catMaybes
-              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_extracttrian"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_extracttrian_upd ::
-                         forall args . Fullfilled "_linalg_extracttrian(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_linalg_extracttrian(ndarray)" args -> IO ()
-_linalg_extracttrian_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_extracttrian"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_linalg_extracttrian(ndarray)" = '[]
-
-_backward_linalg_extracttrian ::
-                              forall args .
-                                Fullfilled "_backward_linalg_extracttrian(ndarray)" args =>
-                                ArgsHMap "_backward_linalg_extracttrian(ndarray)" args ->
-                                  IO [NDArrayHandle]
-_backward_linalg_extracttrian args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_extracttrian"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_extracttrian_upd ::
-                                  forall args .
-                                    Fullfilled "_backward_linalg_extracttrian(ndarray)" args =>
-                                    [NDArrayHandle] ->
-                                      ArgsHMap "_backward_linalg_extracttrian(ndarray)" args ->
-                                        IO ()
-_backward_linalg_extracttrian_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_extracttrian"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_maketrian(ndarray)" =
-     '[ '("offset", AttrOpt Int), '("lower", AttrOpt Bool),
-        '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_maketrian ::
-                  forall args . Fullfilled "_linalg_maketrian(ndarray)" args =>
-                    ArgsHMap "_linalg_maketrian(ndarray)" args -> IO [NDArrayHandle]
-_linalg_maketrian args
-  = let scalarArgs
-          = catMaybes
-              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_maketrian"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_maketrian_upd ::
-                      forall args . Fullfilled "_linalg_maketrian(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_linalg_maketrian(ndarray)" args -> IO ()
-_linalg_maketrian_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_maketrian"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_maketrian(ndarray)" =
-     '[]
-
-_backward_linalg_maketrian ::
-                           forall args .
-                             Fullfilled "_backward_linalg_maketrian(ndarray)" args =>
-                             ArgsHMap "_backward_linalg_maketrian(ndarray)" args ->
-                               IO [NDArrayHandle]
-_backward_linalg_maketrian args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_maketrian"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_maketrian_upd ::
-                               forall args .
-                                 Fullfilled "_backward_linalg_maketrian(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_backward_linalg_maketrian(ndarray)" args -> IO ()
-_backward_linalg_maketrian_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_maketrian"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_syrk(ndarray)" =
-     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_syrk ::
-             forall args . Fullfilled "_linalg_syrk(ndarray)" args =>
-               ArgsHMap "_linalg_syrk(ndarray)" args -> IO [NDArrayHandle]
-_linalg_syrk args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_syrk_upd ::
-                 forall args . Fullfilled "_linalg_syrk(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_linalg_syrk(ndarray)" args -> IO ()
-_linalg_syrk_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_syrk(ndarray)" = '[]
-
-_backward_linalg_syrk ::
-                      forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args =>
-                        ArgsHMap "_backward_linalg_syrk(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_linalg_syrk args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_syrk_upd ::
-                          forall args . Fullfilled "_backward_linalg_syrk(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_linalg_syrk(ndarray)" args -> IO ()
-_backward_linalg_syrk_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syrk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_gelqf(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_gelqf ::
-              forall args . Fullfilled "_linalg_gelqf(ndarray)" args =>
-                ArgsHMap "_linalg_gelqf(ndarray)" args -> IO [NDArrayHandle]
-_linalg_gelqf args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_gelqf_upd ::
-                  forall args . Fullfilled "_linalg_gelqf(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_gelqf(ndarray)" args -> IO ()
-_linalg_gelqf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_gelqf(ndarray)" = '[]
-
-_backward_linalg_gelqf ::
-                       forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_gelqf(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_gelqf args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_gelqf_upd ::
-                           forall args . Fullfilled "_backward_linalg_gelqf(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_gelqf(ndarray)" args -> IO ()
-_backward_linalg_gelqf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gelqf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_syevd(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_syevd ::
-              forall args . Fullfilled "_linalg_syevd(ndarray)" args =>
-                ArgsHMap "_linalg_syevd(ndarray)" args -> IO [NDArrayHandle]
-_linalg_syevd args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_syevd_upd ::
-                  forall args . Fullfilled "_linalg_syevd(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_linalg_syevd(ndarray)" args -> IO ()
-_linalg_syevd_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_syevd(ndarray)" = '[]
-
-_backward_linalg_syevd ::
-                       forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args =>
-                         ArgsHMap "_backward_linalg_syevd(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_linalg_syevd args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_syevd_upd ::
-                           forall args . Fullfilled "_backward_linalg_syevd(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_linalg_syevd(ndarray)" args -> IO ()
-_backward_linalg_syevd_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syevd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_linalg_inverse(ndarray)" =
-     '[ '("_A", AttrOpt NDArrayHandle)]
-
-_linalg_inverse ::
-                forall args . Fullfilled "_linalg_inverse(ndarray)" args =>
-                  ArgsHMap "_linalg_inverse(ndarray)" args -> IO [NDArrayHandle]
-_linalg_inverse args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_inverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_linalg_inverse_upd ::
-                    forall args . Fullfilled "_linalg_inverse(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_linalg_inverse(ndarray)" args -> IO ()
-_linalg_inverse_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_inverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linalg_inverse(ndarray)" =
-     '[]
-
-_backward_linalg_inverse ::
-                         forall args .
-                           Fullfilled "_backward_linalg_inverse(ndarray)" args =>
-                           ArgsHMap "_backward_linalg_inverse(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_linalg_inverse args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_inverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linalg_inverse_upd ::
-                             forall args .
-                               Fullfilled "_backward_linalg_inverse(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_linalg_inverse(ndarray)" args -> IO ()
-_backward_linalg_inverse_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_inverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_histogram(ndarray)" =
-     '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle), '("bins", AttrOpt NDArrayHandle)]
-
-_histogram ::
-           forall args . Fullfilled "_histogram(ndarray)" args =>
-             ArgsHMap "_histogram(ndarray)" args -> IO [NDArrayHandle]
-_histogram args
-  = let scalarArgs
-          = catMaybes
-              [("bin_cnt",) . showValue <$>
-                 (args !? #bin_cnt :: Maybe (Maybe Int)),
-               ("range",) . showValue <$> (args !? #range :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_histogram"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_histogram_upd ::
-               forall args . Fullfilled "_histogram(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_histogram(ndarray)" args -> IO ()
-_histogram_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("bin_cnt",) . showValue <$>
-                 (args !? #bin_cnt :: Maybe (Maybe Int)),
-               ("range",) . showValue <$> (args !? #range :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("bins",) <$> (args !? #bins :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_histogram"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cast_storage(ndarray)" =
-     '[ '("stype",
-          AttrReq (EnumType '["csr", "default", "row_sparse"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-cast_storage ::
-             forall args . Fullfilled "cast_storage(ndarray)" args =>
-               ArgsHMap "cast_storage(ndarray)" args -> IO [NDArrayHandle]
-cast_storage args
-  = let scalarArgs
-          = catMaybes
-              [("stype",) . showValue <$>
-                 (args !? #stype ::
-                    Maybe (EnumType '["csr", "default", "row_sparse"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cast_storage"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cast_storage_upd ::
-                 forall args . Fullfilled "cast_storage(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "cast_storage(ndarray)" args -> IO ()
-cast_storage_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("stype",) . showValue <$>
-                 (args !? #stype ::
-                    Maybe (EnumType '["csr", "default", "row_sparse"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cast_storage"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_equal_scalar ::
-              forall args . Fullfilled "_equal_scalar(ndarray)" args =>
-                ArgsHMap "_equal_scalar(ndarray)" args -> IO [NDArrayHandle]
-_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_equal_scalar_upd ::
-                  forall args . Fullfilled "_equal_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_equal_scalar(ndarray)" args -> IO ()
-_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_not_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_not_equal_scalar ::
-                  forall args . Fullfilled "_not_equal_scalar(ndarray)" args =>
-                    ArgsHMap "_not_equal_scalar(ndarray)" args -> IO [NDArrayHandle]
-_not_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_not_equal_scalar_upd ::
-                      forall args . Fullfilled "_not_equal_scalar(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_not_equal_scalar(ndarray)" args -> IO ()
-_not_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_greater_scalar ::
-                forall args . Fullfilled "_greater_scalar(ndarray)" args =>
-                  ArgsHMap "_greater_scalar(ndarray)" args -> IO [NDArrayHandle]
-_greater_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_scalar_upd ::
-                    forall args . Fullfilled "_greater_scalar(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_greater_scalar(ndarray)" args -> IO ()
-_greater_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_greater_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_greater_equal_scalar ::
-                      forall args . Fullfilled "_greater_equal_scalar(ndarray)" args =>
-                        ArgsHMap "_greater_equal_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_greater_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_greater_equal_scalar_upd ::
-                          forall args . Fullfilled "_greater_equal_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_greater_equal_scalar(ndarray)" args -> IO ()
-_greater_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_lesser_scalar ::
-               forall args . Fullfilled "_lesser_scalar(ndarray)" args =>
-                 ArgsHMap "_lesser_scalar(ndarray)" args -> IO [NDArrayHandle]
-_lesser_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_scalar_upd ::
-                   forall args . Fullfilled "_lesser_scalar(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_lesser_scalar(ndarray)" args -> IO ()
-_lesser_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_lesser_equal_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_lesser_equal_scalar ::
-                     forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args =>
-                       ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO [NDArrayHandle]
-_lesser_equal_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_lesser_equal_scalar_upd ::
-                         forall args . Fullfilled "_lesser_equal_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_lesser_equal_scalar(ndarray)" args -> IO ()
-_lesser_equal_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_and_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_logical_and_scalar ::
-                    forall args . Fullfilled "_logical_and_scalar(ndarray)" args =>
-                      ArgsHMap "_logical_and_scalar(ndarray)" args -> IO [NDArrayHandle]
-_logical_and_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_and_scalar_upd ::
-                        forall args . Fullfilled "_logical_and_scalar(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_logical_and_scalar(ndarray)" args -> IO ()
-_logical_and_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_or_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_logical_or_scalar ::
-                   forall args . Fullfilled "_logical_or_scalar(ndarray)" args =>
-                     ArgsHMap "_logical_or_scalar(ndarray)" args -> IO [NDArrayHandle]
-_logical_or_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_or_scalar_upd ::
-                       forall args . Fullfilled "_logical_or_scalar(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_logical_or_scalar(ndarray)" args -> IO ()
-_logical_or_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_logical_xor_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_logical_xor_scalar ::
-                    forall args . Fullfilled "_logical_xor_scalar(ndarray)" args =>
-                      ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO [NDArrayHandle]
-_logical_xor_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_logical_xor_scalar_upd ::
-                        forall args . Fullfilled "_logical_xor_scalar(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_logical_xor_scalar(ndarray)" args -> IO ()
-_logical_xor_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "relu(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-relu ::
-     forall args . Fullfilled "relu(ndarray)" args =>
-       ArgsHMap "relu(ndarray)" args -> IO [NDArrayHandle]
-relu args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-relu_upd ::
-         forall args . Fullfilled "relu(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "relu(ndarray)" args -> IO ()
-relu_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_relu(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_relu ::
-               forall args . Fullfilled "_backward_relu(ndarray)" args =>
-                 ArgsHMap "_backward_relu(ndarray)" args -> IO [NDArrayHandle]
-_backward_relu args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_relu_upd ::
-                   forall args . Fullfilled "_backward_relu(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_relu(ndarray)" args -> IO ()
-_backward_relu_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_relu"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sigmoid(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sigmoid ::
-        forall args . Fullfilled "sigmoid(ndarray)" args =>
-          ArgsHMap "sigmoid(ndarray)" args -> IO [NDArrayHandle]
-sigmoid args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sigmoid_upd ::
-            forall args . Fullfilled "sigmoid(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "sigmoid(ndarray)" args -> IO ()
-sigmoid_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sigmoid(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sigmoid ::
-                  forall args . Fullfilled "_backward_sigmoid(ndarray)" args =>
-                    ArgsHMap "_backward_sigmoid(ndarray)" args -> IO [NDArrayHandle]
-_backward_sigmoid args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sigmoid_upd ::
-                      forall args . Fullfilled "_backward_sigmoid(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_sigmoid(ndarray)" args -> IO ()
-_backward_sigmoid_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "hard_sigmoid(ndarray)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-hard_sigmoid ::
-             forall args . Fullfilled "hard_sigmoid(ndarray)" args =>
-               ArgsHMap "hard_sigmoid(ndarray)" args -> IO [NDArrayHandle]
-hard_sigmoid args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "hard_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-hard_sigmoid_upd ::
-                 forall args . Fullfilled "hard_sigmoid(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "hard_sigmoid(ndarray)" args -> IO ()
-hard_sigmoid_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "hard_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_hard_sigmoid(ndarray)" = '[]
-
-_backward_hard_sigmoid ::
-                       forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args =>
-                         ArgsHMap "_backward_hard_sigmoid(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_hard_sigmoid args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hard_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_hard_sigmoid_upd ::
-                           forall args . Fullfilled "_backward_hard_sigmoid(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_hard_sigmoid(ndarray)" args -> IO ()
-_backward_hard_sigmoid_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hard_sigmoid"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "softsign(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-softsign ::
-         forall args . Fullfilled "softsign(ndarray)" args =>
-           ArgsHMap "softsign(ndarray)" args -> IO [NDArrayHandle]
-softsign args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softsign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-softsign_upd ::
-             forall args . Fullfilled "softsign(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "softsign(ndarray)" args -> IO ()
-softsign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softsign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_softsign(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_softsign ::
-                   forall args . Fullfilled "_backward_softsign(ndarray)" args =>
-                     ArgsHMap "_backward_softsign(ndarray)" args -> IO [NDArrayHandle]
-_backward_softsign args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softsign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_softsign_upd ::
-                       forall args . Fullfilled "_backward_softsign(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_softsign(ndarray)" args -> IO ()
-_backward_softsign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softsign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_copy(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_copy ::
-      forall args . Fullfilled "_copy(ndarray)" args =>
-        ArgsHMap "_copy(ndarray)" args -> IO [NDArrayHandle]
-_copy args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_copy_upd ::
-          forall args . Fullfilled "_copy(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_copy(ndarray)" args -> IO ()
-_copy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_copy(ndarray)" = '[]
-
-_backward_copy ::
-               forall args . Fullfilled "_backward_copy(ndarray)" args =>
-                 ArgsHMap "_backward_copy(ndarray)" args -> IO [NDArrayHandle]
-_backward_copy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_copy_upd ::
-                   forall args . Fullfilled "_backward_copy(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_copy(ndarray)" args -> IO ()
-_backward_copy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_reshape(ndarray)" = '[]
-
-_backward_reshape ::
-                  forall args . Fullfilled "_backward_reshape(ndarray)" args =>
-                    ArgsHMap "_backward_reshape(ndarray)" args -> IO [NDArrayHandle]
-_backward_reshape args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reshape"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_reshape_upd ::
-                      forall args . Fullfilled "_backward_reshape(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_reshape(ndarray)" args -> IO ()
-_backward_reshape_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reshape"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BlockGrad(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_BlockGrad ::
-           forall args . Fullfilled "_BlockGrad(ndarray)" args =>
-             ArgsHMap "_BlockGrad(ndarray)" args -> IO [NDArrayHandle]
-_BlockGrad args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BlockGrad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BlockGrad_upd ::
-               forall args . Fullfilled "_BlockGrad(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_BlockGrad(ndarray)" args -> IO ()
-_BlockGrad_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BlockGrad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "make_loss(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-make_loss ::
-          forall args . Fullfilled "make_loss(ndarray)" args =>
-            ArgsHMap "make_loss(ndarray)" args -> IO [NDArrayHandle]
-make_loss args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "make_loss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-make_loss_upd ::
-              forall args . Fullfilled "make_loss(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "make_loss(ndarray)" args -> IO ()
-make_loss_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "make_loss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_identity_with_attr_like_rhs(ndarray)"
-     =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_identity_with_attr_like_rhs ::
-                             forall args .
-                               Fullfilled "_identity_with_attr_like_rhs(ndarray)" args =>
-                               ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_identity_with_attr_like_rhs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_identity_with_attr_like_rhs_upd ::
-                                 forall args .
-                                   Fullfilled "_identity_with_attr_like_rhs(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_identity_with_attr_like_rhs(ndarray)" args -> IO ()
-_identity_with_attr_like_rhs_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "reshape_like(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-reshape_like ::
-             forall args . Fullfilled "reshape_like(ndarray)" args =>
-               ArgsHMap "reshape_like(ndarray)" args -> IO [NDArrayHandle]
-reshape_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reshape_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-reshape_like_upd ::
-                 forall args . Fullfilled "reshape_like(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "reshape_like(ndarray)" args -> IO ()
-reshape_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reshape_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "shape_array(ndarray)" =
-     '[ '("lhs_begin", AttrOpt (Maybe Int)),
-        '("lhs_end", AttrOpt (Maybe Int)),
-        '("rhs_begin", AttrOpt (Maybe Int)),
-        '("rhs_end", AttrOpt (Maybe Int)),
-        '("data", AttrOpt NDArrayHandle)]
-
-shape_array ::
-            forall args . Fullfilled "shape_array(ndarray)" args =>
-              ArgsHMap "shape_array(ndarray)" args -> IO [NDArrayHandle]
-shape_array args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_begin",) . showValue <$>
-                 (args !? #lhs_begin :: Maybe (Maybe Int)),
-               ("lhs_end",) . showValue <$>
-                 (args !? #lhs_end :: Maybe (Maybe Int)),
-               ("rhs_begin",) . showValue <$>
-                 (args !? #rhs_begin :: Maybe (Maybe Int)),
-               ("rhs_end",) . showValue <$>
-                 (args !? #rhs_end :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "shape_array"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-shape_array_upd ::
-                forall args . Fullfilled "shape_array(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "shape_array(ndarray)" args -> IO ()
-shape_array_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_begin",) . showValue <$>
-                 (args !? #lhs_begin :: Maybe (Maybe Int)),
-               ("lhs_end",) . showValue <$>
-                 (args !? #lhs_end :: Maybe (Maybe Int)),
-               ("rhs_begin",) . showValue <$>
-                 (args !? #rhs_begin :: Maybe (Maybe Int)),
-               ("rhs_end",) . showValue <$>
-                 (args !? #rhs_end :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "shape_array"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "size_array(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-size_array ::
-           forall args . Fullfilled "size_array(ndarray)" args =>
-             ArgsHMap "size_array(ndarray)" args -> IO [NDArrayHandle]
-size_array args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "size_array"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-size_array_upd ::
-               forall args . Fullfilled "size_array(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "size_array(ndarray)" args -> IO ()
-size_array_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "size_array"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Cast(ndarray)" =
-     '[ '("dtype",
-          AttrReq
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Cast ::
-      forall args . Fullfilled "_Cast(ndarray)" args =>
-        ArgsHMap "_Cast(ndarray)" args -> IO [NDArrayHandle]
-_Cast args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Cast_upd ::
-          forall args . Fullfilled "_Cast(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_Cast(ndarray)" args -> IO ()
-_Cast_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cast(ndarray)" = '[]
-
-_backward_cast ::
-               forall args . Fullfilled "_backward_cast(ndarray)" args =>
-                 ArgsHMap "_backward_cast(ndarray)" args -> IO [NDArrayHandle]
-_backward_cast args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cast_upd ::
-                   forall args . Fullfilled "_backward_cast(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cast(ndarray)" args -> IO ()
-_backward_cast_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "negative(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-negative ::
-         forall args . Fullfilled "negative(ndarray)" args =>
-           ArgsHMap "negative(ndarray)" args -> IO [NDArrayHandle]
-negative args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "negative"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-negative_upd ::
-             forall args . Fullfilled "negative(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "negative(ndarray)" args -> IO ()
-negative_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "negative"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "reciprocal(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-reciprocal ::
-           forall args . Fullfilled "reciprocal(ndarray)" args =>
-             ArgsHMap "reciprocal(ndarray)" args -> IO [NDArrayHandle]
-reciprocal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-reciprocal_upd ::
-               forall args . Fullfilled "reciprocal(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "reciprocal(ndarray)" args -> IO ()
-reciprocal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_reciprocal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_reciprocal ::
-                     forall args . Fullfilled "_backward_reciprocal(ndarray)" args =>
-                       ArgsHMap "_backward_reciprocal(ndarray)" args -> IO [NDArrayHandle]
-_backward_reciprocal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_reciprocal_upd ::
-                         forall args . Fullfilled "_backward_reciprocal(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_reciprocal(ndarray)" args -> IO ()
-_backward_reciprocal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reciprocal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "abs(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-abs ::
-    forall args . Fullfilled "abs(ndarray)" args =>
-      ArgsHMap "abs(ndarray)" args -> IO [NDArrayHandle]
-abs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-abs_upd ::
-        forall args . Fullfilled "abs(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "abs(ndarray)" args -> IO ()
-abs_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_abs(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_abs ::
-              forall args . Fullfilled "_backward_abs(ndarray)" args =>
-                ArgsHMap "_backward_abs(ndarray)" args -> IO [NDArrayHandle]
-_backward_abs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_abs_upd ::
-                  forall args . Fullfilled "_backward_abs(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_abs(ndarray)" args -> IO ()
-_backward_abs_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_abs"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sign(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sign ::
-     forall args . Fullfilled "sign(ndarray)" args =>
-       ArgsHMap "sign(ndarray)" args -> IO [NDArrayHandle]
-sign args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sign_upd ::
-         forall args . Fullfilled "sign(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sign(ndarray)" args -> IO ()
-sign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sign(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sign ::
-               forall args . Fullfilled "_backward_sign(ndarray)" args =>
-                 ArgsHMap "_backward_sign(ndarray)" args -> IO [NDArrayHandle]
-_backward_sign args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sign_upd ::
-                   forall args . Fullfilled "_backward_sign(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_sign(ndarray)" args -> IO ()
-_backward_sign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "round(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-round ::
-      forall args . Fullfilled "round(ndarray)" args =>
-        ArgsHMap "round(ndarray)" args -> IO [NDArrayHandle]
-round args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "round"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-round_upd ::
-          forall args . Fullfilled "round(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "round(ndarray)" args -> IO ()
-round_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "round"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rint(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-rint ::
-     forall args . Fullfilled "rint(ndarray)" args =>
-       ArgsHMap "rint(ndarray)" args -> IO [NDArrayHandle]
-rint args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rint"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rint_upd ::
-         forall args . Fullfilled "rint(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "rint(ndarray)" args -> IO ()
-rint_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rint"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ceil(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-ceil ::
-     forall args . Fullfilled "ceil(ndarray)" args =>
-       ArgsHMap "ceil(ndarray)" args -> IO [NDArrayHandle]
-ceil args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ceil"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ceil_upd ::
-         forall args . Fullfilled "ceil(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "ceil(ndarray)" args -> IO ()
-ceil_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ceil"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "floor(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-floor ::
-      forall args . Fullfilled "floor(ndarray)" args =>
-        ArgsHMap "floor(ndarray)" args -> IO [NDArrayHandle]
-floor args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "floor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-floor_upd ::
-          forall args . Fullfilled "floor(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "floor(ndarray)" args -> IO ()
-floor_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "floor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "trunc(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-trunc ::
-      forall args . Fullfilled "trunc(ndarray)" args =>
-        ArgsHMap "trunc(ndarray)" args -> IO [NDArrayHandle]
-trunc args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "trunc"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-trunc_upd ::
-          forall args . Fullfilled "trunc(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "trunc(ndarray)" args -> IO ()
-trunc_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "trunc"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "fix(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-fix ::
-    forall args . Fullfilled "fix(ndarray)" args =>
-      ArgsHMap "fix(ndarray)" args -> IO [NDArrayHandle]
-fix args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fix"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-fix_upd ::
-        forall args . Fullfilled "fix(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "fix(ndarray)" args -> IO ()
-fix_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fix"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "square(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-square ::
-       forall args . Fullfilled "square(ndarray)" args =>
-         ArgsHMap "square(ndarray)" args -> IO [NDArrayHandle]
-square args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-square_upd ::
-           forall args . Fullfilled "square(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "square(ndarray)" args -> IO ()
-square_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_square(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_square ::
-                 forall args . Fullfilled "_backward_square(ndarray)" args =>
-                   ArgsHMap "_backward_square(ndarray)" args -> IO [NDArrayHandle]
-_backward_square args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_square_upd ::
-                     forall args . Fullfilled "_backward_square(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_square(ndarray)" args -> IO ()
-_backward_square_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sqrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sqrt ::
-     forall args . Fullfilled "sqrt(ndarray)" args =>
-       ArgsHMap "sqrt(ndarray)" args -> IO [NDArrayHandle]
-sqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sqrt_upd ::
-         forall args . Fullfilled "sqrt(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sqrt(ndarray)" args -> IO ()
-sqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sqrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sqrt ::
-               forall args . Fullfilled "_backward_sqrt(ndarray)" args =>
-                 ArgsHMap "_backward_sqrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_sqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sqrt_upd ::
-                   forall args . Fullfilled "_backward_sqrt(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_sqrt(ndarray)" args -> IO ()
-_backward_sqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rsqrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-rsqrt ::
-      forall args . Fullfilled "rsqrt(ndarray)" args =>
-        ArgsHMap "rsqrt(ndarray)" args -> IO [NDArrayHandle]
-rsqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rsqrt_upd ::
-          forall args . Fullfilled "rsqrt(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "rsqrt(ndarray)" args -> IO ()
-rsqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rsqrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rsqrt ::
-                forall args . Fullfilled "_backward_rsqrt(ndarray)" args =>
-                  ArgsHMap "_backward_rsqrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_rsqrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rsqrt_upd ::
-                    forall args . Fullfilled "_backward_rsqrt(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_rsqrt(ndarray)" args -> IO ()
-_backward_rsqrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rsqrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cbrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-cbrt ::
-     forall args . Fullfilled "cbrt(ndarray)" args =>
-       ArgsHMap "cbrt(ndarray)" args -> IO [NDArrayHandle]
-cbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cbrt_upd ::
-         forall args . Fullfilled "cbrt(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "cbrt(ndarray)" args -> IO ()
-cbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cbrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_cbrt ::
-               forall args . Fullfilled "_backward_cbrt(ndarray)" args =>
-                 ArgsHMap "_backward_cbrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_cbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cbrt_upd ::
-                   forall args . Fullfilled "_backward_cbrt(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cbrt(ndarray)" args -> IO ()
-_backward_cbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "erf(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-erf ::
-    forall args . Fullfilled "erf(ndarray)" args =>
-      ArgsHMap "erf(ndarray)" args -> IO [NDArrayHandle]
-erf args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "erf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-erf_upd ::
-        forall args . Fullfilled "erf(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "erf(ndarray)" args -> IO ()
-erf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "erf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_erf(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_erf ::
-              forall args . Fullfilled "_backward_erf(ndarray)" args =>
-                ArgsHMap "_backward_erf(ndarray)" args -> IO [NDArrayHandle]
-_backward_erf args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_erf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_erf_upd ::
-                  forall args . Fullfilled "_backward_erf(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_erf(ndarray)" args -> IO ()
-_backward_erf_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_erf"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "erfinv(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-erfinv ::
-       forall args . Fullfilled "erfinv(ndarray)" args =>
-         ArgsHMap "erfinv(ndarray)" args -> IO [NDArrayHandle]
-erfinv args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "erfinv"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-erfinv_upd ::
-           forall args . Fullfilled "erfinv(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "erfinv(ndarray)" args -> IO ()
-erfinv_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "erfinv"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_erfinv(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_erfinv ::
-                 forall args . Fullfilled "_backward_erfinv(ndarray)" args =>
-                   ArgsHMap "_backward_erfinv(ndarray)" args -> IO [NDArrayHandle]
-_backward_erfinv args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_erfinv"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_erfinv_upd ::
-                     forall args . Fullfilled "_backward_erfinv(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_erfinv(ndarray)" args -> IO ()
-_backward_erfinv_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_erfinv"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rcbrt(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-rcbrt ::
-      forall args . Fullfilled "rcbrt(ndarray)" args =>
-        ArgsHMap "rcbrt(ndarray)" args -> IO [NDArrayHandle]
-rcbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rcbrt_upd ::
-          forall args . Fullfilled "rcbrt(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "rcbrt(ndarray)" args -> IO ()
-rcbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rcbrt(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rcbrt ::
-                forall args . Fullfilled "_backward_rcbrt(ndarray)" args =>
-                  ArgsHMap "_backward_rcbrt(ndarray)" args -> IO [NDArrayHandle]
-_backward_rcbrt args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rcbrt_upd ::
-                    forall args . Fullfilled "_backward_rcbrt(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_rcbrt(ndarray)" args -> IO ()
-_backward_rcbrt_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rcbrt"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "exp(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-exp ::
-    forall args . Fullfilled "exp(ndarray)" args =>
-      ArgsHMap "exp(ndarray)" args -> IO [NDArrayHandle]
-exp args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "exp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-exp_upd ::
-        forall args . Fullfilled "exp(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "exp(ndarray)" args -> IO ()
-exp_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "exp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log ::
-    forall args . Fullfilled "log(ndarray)" args =>
-      ArgsHMap "log(ndarray)" args -> IO [NDArrayHandle]
-log args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log_upd ::
-        forall args . Fullfilled "log(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "log(ndarray)" args -> IO ()
-log_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log10(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log10 ::
-      forall args . Fullfilled "log10(ndarray)" args =>
-        ArgsHMap "log10(ndarray)" args -> IO [NDArrayHandle]
-log10 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log10_upd ::
-          forall args . Fullfilled "log10(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "log10(ndarray)" args -> IO ()
-log10_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log2(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log2 ::
-     forall args . Fullfilled "log2(ndarray)" args =>
-       ArgsHMap "log2(ndarray)" args -> IO [NDArrayHandle]
-log2 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log2_upd ::
-         forall args . Fullfilled "log2(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "log2(ndarray)" args -> IO ()
-log2_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log ::
-              forall args . Fullfilled "_backward_log(ndarray)" args =>
-                ArgsHMap "_backward_log(ndarray)" args -> IO [NDArrayHandle]
-_backward_log args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log_upd ::
-                  forall args . Fullfilled "_backward_log(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_log(ndarray)" args -> IO ()
-_backward_log_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log10(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log10 ::
-                forall args . Fullfilled "_backward_log10(ndarray)" args =>
-                  ArgsHMap "_backward_log10(ndarray)" args -> IO [NDArrayHandle]
-_backward_log10 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log10_upd ::
-                    forall args . Fullfilled "_backward_log10(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_log10(ndarray)" args -> IO ()
-_backward_log10_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log10"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log2(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log2 ::
-               forall args . Fullfilled "_backward_log2(ndarray)" args =>
-                 ArgsHMap "_backward_log2(ndarray)" args -> IO [NDArrayHandle]
-_backward_log2 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log2_upd ::
-                   forall args . Fullfilled "_backward_log2(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_log2(ndarray)" args -> IO ()
-_backward_log2_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log1p(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-log1p ::
-      forall args . Fullfilled "log1p(ndarray)" args =>
-        ArgsHMap "log1p(ndarray)" args -> IO [NDArrayHandle]
-log1p args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log1p_upd ::
-          forall args . Fullfilled "log1p(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "log1p(ndarray)" args -> IO ()
-log1p_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log1p(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_log1p ::
-                forall args . Fullfilled "_backward_log1p(ndarray)" args =>
-                  ArgsHMap "_backward_log1p(ndarray)" args -> IO [NDArrayHandle]
-_backward_log1p args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log1p_upd ::
-                    forall args . Fullfilled "_backward_log1p(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_log1p(ndarray)" args -> IO ()
-_backward_log1p_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log1p"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "expm1(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-expm1 ::
-      forall args . Fullfilled "expm1(ndarray)" args =>
-        ArgsHMap "expm1(ndarray)" args -> IO [NDArrayHandle]
-expm1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-expm1_upd ::
-          forall args . Fullfilled "expm1(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "expm1(ndarray)" args -> IO ()
-expm1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_expm1(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_expm1 ::
-                forall args . Fullfilled "_backward_expm1(ndarray)" args =>
-                  ArgsHMap "_backward_expm1(ndarray)" args -> IO [NDArrayHandle]
-_backward_expm1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_expm1_upd ::
-                    forall args . Fullfilled "_backward_expm1(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_expm1(ndarray)" args -> IO ()
-_backward_expm1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_expm1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "gamma(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-gamma ::
-      forall args . Fullfilled "gamma(ndarray)" args =>
-        ArgsHMap "gamma(ndarray)" args -> IO [NDArrayHandle]
-gamma args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-gamma_upd ::
-          forall args . Fullfilled "gamma(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "gamma(ndarray)" args -> IO ()
-gamma_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_gamma(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_gamma ::
-                forall args . Fullfilled "_backward_gamma(ndarray)" args =>
-                  ArgsHMap "_backward_gamma(ndarray)" args -> IO [NDArrayHandle]
-_backward_gamma args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_gamma_upd ::
-                    forall args . Fullfilled "_backward_gamma(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_gamma(ndarray)" args -> IO ()
-_backward_gamma_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gamma"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "gammaln(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-gammaln ::
-        forall args . Fullfilled "gammaln(ndarray)" args =>
-          ArgsHMap "gammaln(ndarray)" args -> IO [NDArrayHandle]
-gammaln args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-gammaln_upd ::
-            forall args . Fullfilled "gammaln(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "gammaln(ndarray)" args -> IO ()
-gammaln_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_gammaln(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_gammaln ::
-                  forall args . Fullfilled "_backward_gammaln(ndarray)" args =>
-                    ArgsHMap "_backward_gammaln(ndarray)" args -> IO [NDArrayHandle]
-_backward_gammaln args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_gammaln_upd ::
-                      forall args . Fullfilled "_backward_gammaln(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_gammaln(ndarray)" args -> IO ()
-_backward_gammaln_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gammaln"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "logical_not(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-logical_not ::
-            forall args . Fullfilled "logical_not(ndarray)" args =>
-              ArgsHMap "logical_not(ndarray)" args -> IO [NDArrayHandle]
-logical_not args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "logical_not"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-logical_not_upd ::
-                forall args . Fullfilled "logical_not(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "logical_not(ndarray)" args -> IO ()
-logical_not_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "logical_not"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "amp_cast(ndarray)" =
-     '[ '("dtype",
-          AttrReq
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-amp_cast ::
-         forall args . Fullfilled "amp_cast(ndarray)" args =>
-           ArgsHMap "amp_cast(ndarray)" args -> IO [NDArrayHandle]
-amp_cast args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "amp_cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-amp_cast_upd ::
-             forall args . Fullfilled "amp_cast(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "amp_cast(ndarray)" args -> IO ()
-amp_cast_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "amp_cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_amp_cast(ndarray)" = '[]
-
-_backward_amp_cast ::
-                   forall args . Fullfilled "_backward_amp_cast(ndarray)" args =>
-                     ArgsHMap "_backward_amp_cast(ndarray)" args -> IO [NDArrayHandle]
-_backward_amp_cast args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_amp_cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_amp_cast_upd ::
-                       forall args . Fullfilled "_backward_amp_cast(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_amp_cast(ndarray)" args -> IO ()
-_backward_amp_cast_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_amp_cast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "amp_multicast(ndarray)" =
-     '[ '("num_outputs", AttrReq Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-amp_multicast ::
-              forall args . Fullfilled "amp_multicast(ndarray)" args =>
-                ArgsHMap "amp_multicast(ndarray)" args -> IO [NDArrayHandle]
-amp_multicast args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "amp_multicast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-amp_multicast_upd ::
-                  forall args . Fullfilled "amp_multicast(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "amp_multicast(ndarray)" args -> IO ()
-amp_multicast_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "amp_multicast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_amp_multicast(ndarray)" =
-     '[ '("num_outputs", AttrReq Int),
-        '("grad", AttrOpt [NDArrayHandle])]
-
-_backward_amp_multicast ::
-                        forall args . Fullfilled "_backward_amp_multicast(ndarray)" args =>
-                          ArgsHMap "_backward_amp_multicast(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_amp_multicast args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #grad :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_backward_amp_multicast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_amp_multicast_upd ::
-                            forall args . Fullfilled "_backward_amp_multicast(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_amp_multicast(ndarray)" args -> IO ()
-_backward_amp_multicast_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #grad :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_backward_amp_multicast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_add(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_add ::
-             forall args . Fullfilled "elemwise_add(ndarray)" args =>
-               ArgsHMap "elemwise_add(ndarray)" args -> IO [NDArrayHandle]
-elemwise_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_add_upd ::
-                 forall args . Fullfilled "elemwise_add(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_add(ndarray)" args -> IO ()
-elemwise_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_grad_add(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_grad_add ::
-          forall args . Fullfilled "_grad_add(ndarray)" args =>
-            ArgsHMap "_grad_add(ndarray)" args -> IO [NDArrayHandle]
-_grad_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_grad_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_grad_add_upd ::
-              forall args . Fullfilled "_grad_add(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_grad_add(ndarray)" args -> IO ()
-_grad_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_grad_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_add(ndarray)" = '[]
-
-_backward_add ::
-              forall args . Fullfilled "_backward_add(ndarray)" args =>
-                ArgsHMap "_backward_add(ndarray)" args -> IO [NDArrayHandle]
-_backward_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_add_upd ::
-                  forall args . Fullfilled "_backward_add(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_add(ndarray)" args -> IO ()
-_backward_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_sub(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_sub ::
-             forall args . Fullfilled "elemwise_sub(ndarray)" args =>
-               ArgsHMap "elemwise_sub(ndarray)" args -> IO [NDArrayHandle]
-elemwise_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_sub_upd ::
-                 forall args . Fullfilled "elemwise_sub(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_sub(ndarray)" args -> IO ()
-elemwise_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sub(ndarray)" = '[]
-
-_backward_sub ::
-              forall args . Fullfilled "_backward_sub(ndarray)" args =>
-                ArgsHMap "_backward_sub(ndarray)" args -> IO [NDArrayHandle]
-_backward_sub args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sub_upd ::
-                  forall args . Fullfilled "_backward_sub(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_sub(ndarray)" args -> IO ()
-_backward_sub_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sub"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_mul(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_mul ::
-             forall args . Fullfilled "elemwise_mul(ndarray)" args =>
-               ArgsHMap "elemwise_mul(ndarray)" args -> IO [NDArrayHandle]
-elemwise_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_mul_upd ::
-                 forall args . Fullfilled "elemwise_mul(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_mul(ndarray)" args -> IO ()
-elemwise_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mul(ndarray)" = '[]
-
-_backward_mul ::
-              forall args . Fullfilled "_backward_mul(ndarray)" args =>
-                ArgsHMap "_backward_mul(ndarray)" args -> IO [NDArrayHandle]
-_backward_mul args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mul_upd ::
-                  forall args . Fullfilled "_backward_mul(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_mul(ndarray)" args -> IO ()
-_backward_mul_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "elemwise_div(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-elemwise_div ::
-             forall args . Fullfilled "elemwise_div(ndarray)" args =>
-               ArgsHMap "elemwise_div(ndarray)" args -> IO [NDArrayHandle]
-elemwise_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-elemwise_div_upd ::
-                 forall args . Fullfilled "elemwise_div(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "elemwise_div(ndarray)" args -> IO ()
-elemwise_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_div(ndarray)" = '[]
-
-_backward_div ::
-              forall args . Fullfilled "_backward_div(ndarray)" args =>
-                ArgsHMap "_backward_div(ndarray)" args -> IO [NDArrayHandle]
-_backward_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_div_upd ::
-                  forall args . Fullfilled "_backward_div(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_div(ndarray)" args -> IO ()
-_backward_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_mod(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_mod ::
-     forall args . Fullfilled "_mod(ndarray)" args =>
-       ArgsHMap "_mod(ndarray)" args -> IO [NDArrayHandle]
-_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_mod_upd ::
-         forall args . Fullfilled "_mod(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_mod(ndarray)" args -> IO ()
-_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mod(ndarray)" = '[]
-
-_backward_mod ::
-              forall args . Fullfilled "_backward_mod(ndarray)" args =>
-                ArgsHMap "_backward_mod(ndarray)" args -> IO [NDArrayHandle]
-_backward_mod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mod_upd ::
-                  forall args . Fullfilled "_backward_mod(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_mod(ndarray)" args -> IO ()
-_backward_mod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_elemwise_div(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_scatter_elemwise_div ::
-                      forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args =>
-                        ArgsHMap "_scatter_elemwise_div(ndarray)" args ->
-                          IO [NDArrayHandle]
-_scatter_elemwise_div args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_elemwise_div_upd ::
-                          forall args . Fullfilled "_scatter_elemwise_div(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_scatter_elemwise_div(ndarray)" args -> IO ()
-_scatter_elemwise_div_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_elemwise_div"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_plus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_scatter_plus_scalar ::
-                     forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args =>
-                       ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_scatter_plus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_plus_scalar_upd ::
-                         forall args . Fullfilled "_scatter_plus_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_scatter_plus_scalar(ndarray)" args -> IO ()
-_scatter_plus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_minus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_scatter_minus_scalar ::
-                      forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args =>
-                        ArgsHMap "_scatter_minus_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_scatter_minus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_minus_scalar_upd ::
-                          forall args . Fullfilled "_scatter_minus_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_scatter_minus_scalar(ndarray)" args -> IO ()
-_scatter_minus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Embedding(ndarray)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle)]
-
-_Embedding ::
-           forall args . Fullfilled "_Embedding(ndarray)" args =>
-             ArgsHMap "_Embedding(ndarray)" args -> IO [NDArrayHandle]
-_Embedding args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Embedding_upd ::
-               forall args . Fullfilled "_Embedding(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_Embedding(ndarray)" args -> IO ()
-_Embedding_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_SparseEmbedding(ndarray)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle)]
-
-_contrib_SparseEmbedding ::
-                         forall args .
-                           Fullfilled "_contrib_SparseEmbedding(ndarray)" args =>
-                           ArgsHMap "_contrib_SparseEmbedding(ndarray)" args ->
-                             IO [NDArrayHandle]
-_contrib_SparseEmbedding args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_SparseEmbedding_upd ::
-                             forall args .
-                               Fullfilled "_contrib_SparseEmbedding(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_contrib_SparseEmbedding(ndarray)" args -> IO ()
-_contrib_SparseEmbedding_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Embedding(ndarray)" = '[]
-
-_backward_Embedding ::
-                    forall args . Fullfilled "_backward_Embedding(ndarray)" args =>
-                      ArgsHMap "_backward_Embedding(ndarray)" args -> IO [NDArrayHandle]
-_backward_Embedding args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Embedding_upd ::
-                        forall args . Fullfilled "_backward_Embedding(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_Embedding(ndarray)" args -> IO ()
-_backward_Embedding_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Embedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SparseEmbedding(ndarray)" =
-     '[]
-
-_backward_SparseEmbedding ::
-                          forall args .
-                            Fullfilled "_backward_SparseEmbedding(ndarray)" args =>
-                            ArgsHMap "_backward_SparseEmbedding(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_SparseEmbedding args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SparseEmbedding_upd ::
-                              forall args .
-                                Fullfilled "_backward_SparseEmbedding(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_SparseEmbedding(ndarray)" args -> IO ()
-_backward_SparseEmbedding_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SparseEmbedding"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "take(ndarray)" =
-     '[ '("axis", AttrOpt Int),
-        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),
-        '("a", AttrOpt NDArrayHandle), '("indices", AttrOpt NDArrayHandle)]
-
-take ::
-     forall args . Fullfilled "take(ndarray)" args =>
-       ArgsHMap "take(ndarray)" args -> IO [NDArrayHandle]
-take args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-take_upd ::
-         forall args . Fullfilled "take(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "take(ndarray)" args -> IO ()
-take_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_take(ndarray)" = '[]
-
-_backward_take ::
-               forall args . Fullfilled "_backward_take(ndarray)" args =>
-                 ArgsHMap "_backward_take(ndarray)" args -> IO [NDArrayHandle]
-_backward_take args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_take_upd ::
-                   forall args . Fullfilled "_backward_take(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_take(ndarray)" args -> IO ()
-_backward_take_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "batch_take(ndarray)" =
-     '[ '("a", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-batch_take ::
-           forall args . Fullfilled "batch_take(ndarray)" args =>
-             ArgsHMap "batch_take(ndarray)" args -> IO [NDArrayHandle]
-batch_take args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-batch_take_upd ::
-               forall args . Fullfilled "batch_take(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "batch_take(ndarray)" args -> IO ()
-batch_take_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_take"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "one_hot(ndarray)" =
-     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),
-        '("off_value", AttrOpt Double),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("indices", AttrOpt NDArrayHandle)]
-
-one_hot ::
-        forall args . Fullfilled "one_hot(ndarray)" args =>
-          ArgsHMap "one_hot(ndarray)" args -> IO [NDArrayHandle]
-one_hot args
-  = let scalarArgs
-          = catMaybes
-              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),
-               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),
-               ("off_value",) . showValue <$>
-                 (args !? #off_value :: Maybe Double),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "one_hot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-one_hot_upd ::
-            forall args . Fullfilled "one_hot(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "one_hot(ndarray)" args -> IO ()
-one_hot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),
-               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),
-               ("off_value",) . showValue <$>
-                 (args !? #off_value :: Maybe Double),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "one_hot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "gather_nd(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-gather_nd ::
-          forall args . Fullfilled "gather_nd(ndarray)" args =>
-            ArgsHMap "gather_nd(ndarray)" args -> IO [NDArrayHandle]
-gather_nd args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gather_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-gather_nd_upd ::
-              forall args . Fullfilled "gather_nd(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "gather_nd(ndarray)" args -> IO ()
-gather_nd_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gather_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "scatter_nd(ndarray)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-scatter_nd ::
-           forall args . Fullfilled "scatter_nd(ndarray)" args =>
-             ArgsHMap "scatter_nd(ndarray)" args -> IO [NDArrayHandle]
-scatter_nd args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "scatter_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-scatter_nd_upd ::
-               forall args . Fullfilled "scatter_nd(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "scatter_nd(ndarray)" args -> IO ()
-scatter_nd_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "scatter_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_gather_nd(ndarray)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-_backward_gather_nd ::
-                    forall args . Fullfilled "_backward_gather_nd(ndarray)" args =>
-                      ArgsHMap "_backward_gather_nd(ndarray)" args -> IO [NDArrayHandle]
-_backward_gather_nd args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gather_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_gather_nd_upd ::
-                        forall args . Fullfilled "_backward_gather_nd(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_gather_nd(ndarray)" args -> IO ()
-_backward_gather_nd_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gather_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_scatter_set_nd(ndarray)" =
-     '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-_scatter_set_nd ::
-                forall args . Fullfilled "_scatter_set_nd(ndarray)" args =>
-                  ArgsHMap "_scatter_set_nd(ndarray)" args -> IO [NDArrayHandle]
-_scatter_set_nd args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_set_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_scatter_set_nd_upd ::
-                    forall args . Fullfilled "_scatter_set_nd(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_scatter_set_nd(ndarray)" args -> IO ()
-_scatter_set_nd_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_set_nd"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_equal ::
-                forall args . Fullfilled "broadcast_equal(ndarray)" args =>
-                  ArgsHMap "broadcast_equal(ndarray)" args -> IO [NDArrayHandle]
-broadcast_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_equal_upd ::
-                    forall args . Fullfilled "broadcast_equal(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "broadcast_equal(ndarray)" args -> IO ()
-broadcast_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_not_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_not_equal ::
-                    forall args . Fullfilled "broadcast_not_equal(ndarray)" args =>
-                      ArgsHMap "broadcast_not_equal(ndarray)" args -> IO [NDArrayHandle]
-broadcast_not_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_not_equal_upd ::
-                        forall args . Fullfilled "broadcast_not_equal(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "broadcast_not_equal(ndarray)" args -> IO ()
-broadcast_not_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_not_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_greater(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_greater ::
-                  forall args . Fullfilled "broadcast_greater(ndarray)" args =>
-                    ArgsHMap "broadcast_greater(ndarray)" args -> IO [NDArrayHandle]
-broadcast_greater args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_greater_upd ::
-                      forall args . Fullfilled "broadcast_greater(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "broadcast_greater(ndarray)" args -> IO ()
-broadcast_greater_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_greater_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_greater_equal ::
-                        forall args . Fullfilled "broadcast_greater_equal(ndarray)" args =>
-                          ArgsHMap "broadcast_greater_equal(ndarray)" args ->
-                            IO [NDArrayHandle]
-broadcast_greater_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_greater_equal_upd ::
-                            forall args . Fullfilled "broadcast_greater_equal(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "broadcast_greater_equal(ndarray)" args -> IO ()
-broadcast_greater_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_lesser(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_lesser ::
-                 forall args . Fullfilled "broadcast_lesser(ndarray)" args =>
-                   ArgsHMap "broadcast_lesser(ndarray)" args -> IO [NDArrayHandle]
-broadcast_lesser args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_lesser_upd ::
-                     forall args . Fullfilled "broadcast_lesser(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "broadcast_lesser(ndarray)" args -> IO ()
-broadcast_lesser_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_lesser_equal(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_lesser_equal ::
-                       forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args =>
-                         ArgsHMap "broadcast_lesser_equal(ndarray)" args ->
-                           IO [NDArrayHandle]
-broadcast_lesser_equal args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_lesser_equal_upd ::
-                           forall args . Fullfilled "broadcast_lesser_equal(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "broadcast_lesser_equal(ndarray)" args -> IO ()
-broadcast_lesser_equal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser_equal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_logical_and(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_logical_and ::
-                      forall args . Fullfilled "broadcast_logical_and(ndarray)" args =>
-                        ArgsHMap "broadcast_logical_and(ndarray)" args ->
-                          IO [NDArrayHandle]
-broadcast_logical_and args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_and"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_logical_and_upd ::
-                          forall args . Fullfilled "broadcast_logical_and(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "broadcast_logical_and(ndarray)" args -> IO ()
-broadcast_logical_and_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_and"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_logical_or(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_logical_or ::
-                     forall args . Fullfilled "broadcast_logical_or(ndarray)" args =>
-                       ArgsHMap "broadcast_logical_or(ndarray)" args -> IO [NDArrayHandle]
-broadcast_logical_or args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_or"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_logical_or_upd ::
-                         forall args . Fullfilled "broadcast_logical_or(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "broadcast_logical_or(ndarray)" args -> IO ()
-broadcast_logical_or_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_or"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_logical_xor(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_logical_xor ::
-                      forall args . Fullfilled "broadcast_logical_xor(ndarray)" args =>
-                        ArgsHMap "broadcast_logical_xor(ndarray)" args ->
-                          IO [NDArrayHandle]
-broadcast_logical_xor args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_xor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_logical_xor_upd ::
-                          forall args . Fullfilled "broadcast_logical_xor(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "broadcast_logical_xor(ndarray)" args -> IO ()
-broadcast_logical_xor_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_xor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_plus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_plus_scalar ::
-             forall args . Fullfilled "_plus_scalar(ndarray)" args =>
-               ArgsHMap "_plus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_plus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_plus_scalar_upd ::
-                 forall args . Fullfilled "_plus_scalar(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_plus_scalar(ndarray)" args -> IO ()
-_plus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_plus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_minus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_minus_scalar ::
-              forall args . Fullfilled "_minus_scalar(ndarray)" args =>
-                ArgsHMap "_minus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_minus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_minus_scalar_upd ::
-                  forall args . Fullfilled "_minus_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_minus_scalar(ndarray)" args -> IO ()
-_minus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rminus_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rminus_scalar ::
-               forall args . Fullfilled "_rminus_scalar(ndarray)" args =>
-                 ArgsHMap "_rminus_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rminus_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rminus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rminus_scalar_upd ::
-                   forall args . Fullfilled "_rminus_scalar(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_rminus_scalar(ndarray)" args -> IO ()
-_rminus_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rminus_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_mul_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_mul_scalar ::
-            forall args . Fullfilled "_mul_scalar(ndarray)" args =>
-              ArgsHMap "_mul_scalar(ndarray)" args -> IO [NDArrayHandle]
-_mul_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_mul_scalar_upd ::
-                forall args . Fullfilled "_mul_scalar(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_mul_scalar(ndarray)" args -> IO ()
-_mul_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mul_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_backward_mul_scalar ::
-                     forall args . Fullfilled "_backward_mul_scalar(ndarray)" args =>
-                       ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO [NDArrayHandle]
-_backward_mul_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mul_scalar_upd ::
-                         forall args . Fullfilled "_backward_mul_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_mul_scalar(ndarray)" args -> IO ()
-_backward_mul_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_div_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_div_scalar ::
-            forall args . Fullfilled "_div_scalar(ndarray)" args =>
-              ArgsHMap "_div_scalar(ndarray)" args -> IO [NDArrayHandle]
-_div_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_div_scalar_upd ::
-                forall args . Fullfilled "_div_scalar(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_div_scalar(ndarray)" args -> IO ()
-_div_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_div_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_backward_div_scalar ::
-                     forall args . Fullfilled "_backward_div_scalar(ndarray)" args =>
-                       ArgsHMap "_backward_div_scalar(ndarray)" args -> IO [NDArrayHandle]
-_backward_div_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_div_scalar_upd ::
-                         forall args . Fullfilled "_backward_div_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_div_scalar(ndarray)" args -> IO ()
-_backward_div_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rdiv_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rdiv_scalar ::
-             forall args . Fullfilled "_rdiv_scalar(ndarray)" args =>
-               ArgsHMap "_rdiv_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rdiv_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rdiv_scalar_upd ::
-                 forall args . Fullfilled "_rdiv_scalar(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_rdiv_scalar(ndarray)" args -> IO ()
-_rdiv_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rdiv_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rdiv_scalar ::
-                      forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args =>
-                        ArgsHMap "_backward_rdiv_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_rdiv_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rdiv_scalar_upd ::
-                          forall args . Fullfilled "_backward_rdiv_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_rdiv_scalar(ndarray)" args -> IO ()
-_backward_rdiv_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rdiv_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_mod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_mod_scalar ::
-            forall args . Fullfilled "_mod_scalar(ndarray)" args =>
-              ArgsHMap "_mod_scalar(ndarray)" args -> IO [NDArrayHandle]
-_mod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_mod_scalar_upd ::
-                forall args . Fullfilled "_mod_scalar(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_mod_scalar(ndarray)" args -> IO ()
-_mod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_mod_scalar ::
-                     forall args . Fullfilled "_backward_mod_scalar(ndarray)" args =>
-                       ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO [NDArrayHandle]
-_backward_mod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mod_scalar_upd ::
-                         forall args . Fullfilled "_backward_mod_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_mod_scalar(ndarray)" args -> IO ()
-_backward_mod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rmod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rmod_scalar ::
-             forall args . Fullfilled "_rmod_scalar(ndarray)" args =>
-               ArgsHMap "_rmod_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rmod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rmod_scalar_upd ::
-                 forall args . Fullfilled "_rmod_scalar(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_rmod_scalar(ndarray)" args -> IO ()
-_rmod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rmod_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rmod_scalar ::
-                      forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args =>
-                        ArgsHMap "_backward_rmod_scalar(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_rmod_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rmod_scalar_upd ::
-                          forall args . Fullfilled "_backward_rmod_scalar(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_rmod_scalar(ndarray)" args -> IO ()
-_backward_rmod_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rmod_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_ravel_multi_index(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-_ravel_multi_index ::
-                   forall args . Fullfilled "_ravel_multi_index(ndarray)" args =>
-                     ArgsHMap "_ravel_multi_index(ndarray)" args -> IO [NDArrayHandle]
-_ravel_multi_index args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ravel_multi_index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_ravel_multi_index_upd ::
-                       forall args . Fullfilled "_ravel_multi_index(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_ravel_multi_index(ndarray)" args -> IO ()
-_ravel_multi_index_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ravel_multi_index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_unravel_index(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-_unravel_index ::
-               forall args . Fullfilled "_unravel_index(ndarray)" args =>
-                 ArgsHMap "_unravel_index(ndarray)" args -> IO [NDArrayHandle]
-_unravel_index args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_unravel_index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_unravel_index_upd ::
-                   forall args . Fullfilled "_unravel_index(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_unravel_index(ndarray)" args -> IO ()
-_unravel_index_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_unravel_index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sum(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-sum ::
-    forall args . Fullfilled "sum(ndarray)" args =>
-      ArgsHMap "sum(ndarray)" args -> IO [NDArrayHandle]
-sum args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sum_upd ::
-        forall args . Fullfilled "sum(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "sum(ndarray)" args -> IO ()
-sum_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sum(ndarray)" = '[]
-
-_backward_sum ::
-              forall args . Fullfilled "_backward_sum(ndarray)" args =>
-                ArgsHMap "_backward_sum(ndarray)" args -> IO [NDArrayHandle]
-_backward_sum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sum_upd ::
-                  forall args . Fullfilled "_backward_sum(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_sum(ndarray)" args -> IO ()
-_backward_sum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "mean(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-mean ::
-     forall args . Fullfilled "mean(ndarray)" args =>
-       ArgsHMap "mean(ndarray)" args -> IO [NDArrayHandle]
-mean args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-mean_upd ::
-         forall args . Fullfilled "mean(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "mean(ndarray)" args -> IO ()
-mean_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mean(ndarray)" = '[]
-
-_backward_mean ::
-               forall args . Fullfilled "_backward_mean(ndarray)" args =>
-                 ArgsHMap "_backward_mean(ndarray)" args -> IO [NDArrayHandle]
-_backward_mean args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mean_upd ::
-                   forall args . Fullfilled "_backward_mean(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_mean(ndarray)" args -> IO ()
-_backward_mean_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mean"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "prod(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-prod ::
-     forall args . Fullfilled "prod(ndarray)" args =>
-       ArgsHMap "prod(ndarray)" args -> IO [NDArrayHandle]
-prod args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-prod_upd ::
-         forall args . Fullfilled "prod(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "prod(ndarray)" args -> IO ()
-prod_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_prod(ndarray)" = '[]
-
-_backward_prod ::
-               forall args . Fullfilled "_backward_prod(ndarray)" args =>
-                 ArgsHMap "_backward_prod(ndarray)" args -> IO [NDArrayHandle]
-_backward_prod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_prod_upd ::
-                   forall args . Fullfilled "_backward_prod(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_prod(ndarray)" args -> IO ()
-_backward_prod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_prod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "nansum(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-nansum ::
-       forall args . Fullfilled "nansum(ndarray)" args =>
-         ArgsHMap "nansum(ndarray)" args -> IO [NDArrayHandle]
-nansum args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-nansum_upd ::
-           forall args . Fullfilled "nansum(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "nansum(ndarray)" args -> IO ()
-nansum_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_nansum(ndarray)" = '[]
-
-_backward_nansum ::
-                 forall args . Fullfilled "_backward_nansum(ndarray)" args =>
-                   ArgsHMap "_backward_nansum(ndarray)" args -> IO [NDArrayHandle]
-_backward_nansum args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_nansum_upd ::
-                     forall args . Fullfilled "_backward_nansum(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_nansum(ndarray)" args -> IO ()
-_backward_nansum_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nansum"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "nanprod(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-nanprod ::
-        forall args . Fullfilled "nanprod(ndarray)" args =>
-          ArgsHMap "nanprod(ndarray)" args -> IO [NDArrayHandle]
-nanprod args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-nanprod_upd ::
-            forall args . Fullfilled "nanprod(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "nanprod(ndarray)" args -> IO ()
-nanprod_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_nanprod(ndarray)" = '[]
-
-_backward_nanprod ::
-                  forall args . Fullfilled "_backward_nanprod(ndarray)" args =>
-                    ArgsHMap "_backward_nanprod(ndarray)" args -> IO [NDArrayHandle]
-_backward_nanprod args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_nanprod_upd ::
-                      forall args . Fullfilled "_backward_nanprod(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_nanprod(ndarray)" args -> IO ()
-_backward_nanprod_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nanprod"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "max(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-max ::
-    forall args . Fullfilled "max(ndarray)" args =>
-      ArgsHMap "max(ndarray)" args -> IO [NDArrayHandle]
-max args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-max_upd ::
-        forall args . Fullfilled "max(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "max(ndarray)" args -> IO ()
-max_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_max(ndarray)" = '[]
-
-_backward_max ::
-              forall args . Fullfilled "_backward_max(ndarray)" args =>
-                ArgsHMap "_backward_max(ndarray)" args -> IO [NDArrayHandle]
-_backward_max args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_max_upd ::
-                  forall args . Fullfilled "_backward_max(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_max(ndarray)" args -> IO ()
-_backward_max_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_max"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "min(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-min ::
-    forall args . Fullfilled "min(ndarray)" args =>
-      ArgsHMap "min(ndarray)" args -> IO [NDArrayHandle]
-min args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-min_upd ::
-        forall args . Fullfilled "min(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "min(ndarray)" args -> IO ()
-min_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_min(ndarray)" = '[]
-
-_backward_min ::
-              forall args . Fullfilled "_backward_min(ndarray)" args =>
-                ArgsHMap "_backward_min(ndarray)" args -> IO [NDArrayHandle]
-_backward_min args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_min_upd ::
-                  forall args . Fullfilled "_backward_min(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_min(ndarray)" args -> IO ()
-_backward_min_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_min"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_axis(ndarray)" =
-     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-broadcast_axis ::
-               forall args . Fullfilled "broadcast_axis(ndarray)" args =>
-                 ArgsHMap "broadcast_axis(ndarray)" args -> IO [NDArrayHandle]
-broadcast_axis args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_axis_upd ::
-                   forall args . Fullfilled "broadcast_axis(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "broadcast_axis(ndarray)" args -> IO ()
-broadcast_axis_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_to(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-broadcast_to ::
-             forall args . Fullfilled "broadcast_to(ndarray)" args =>
-               ArgsHMap "broadcast_to(ndarray)" args -> IO [NDArrayHandle]
-broadcast_to args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_to"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_to_upd ::
-                 forall args . Fullfilled "broadcast_to(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "broadcast_to(ndarray)" args -> IO ()
-broadcast_to_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_to"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_broadcast_backward(ndarray)" = '[]
-
-_broadcast_backward ::
-                    forall args . Fullfilled "_broadcast_backward(ndarray)" args =>
-                      ArgsHMap "_broadcast_backward(ndarray)" args -> IO [NDArrayHandle]
-_broadcast_backward args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_broadcast_backward"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_broadcast_backward_upd ::
-                        forall args . Fullfilled "_broadcast_backward(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_broadcast_backward(ndarray)" args -> IO ()
-_broadcast_backward_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_broadcast_backward"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "broadcast_like(ndarray)" =
-     '[ '("lhs_axes", AttrOpt (Maybe [Int])),
-        '("rhs_axes", AttrOpt (Maybe [Int])),
-        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-broadcast_like ::
-               forall args . Fullfilled "broadcast_like(ndarray)" args =>
-                 ArgsHMap "broadcast_like(ndarray)" args -> IO [NDArrayHandle]
-broadcast_like args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_axes",) . showValue <$>
-                 (args !? #lhs_axes :: Maybe (Maybe [Int])),
-               ("rhs_axes",) . showValue <$>
-                 (args !? #rhs_axes :: Maybe (Maybe [Int]))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-broadcast_like_upd ::
-                   forall args . Fullfilled "broadcast_like(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "broadcast_like(ndarray)" args -> IO ()
-broadcast_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_axes",) . showValue <$>
-                 (args !? #lhs_axes :: Maybe (Maybe [Int])),
-               ("rhs_axes",) . showValue <$>
-                 (args !? #rhs_axes :: Maybe (Maybe [Int]))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "norm(ndarray)" =
-     '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])),
-        '("out_dtype",
-          AttrOpt
-            (Maybe
-               (EnumType
-                  '["float16", "float32", "float64", "int32", "int64", "int8"]))),
-        '("keepdims", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-norm ::
-     forall args . Fullfilled "norm(ndarray)" args =>
-       ArgsHMap "norm(ndarray)" args -> IO [NDArrayHandle]
-norm args
-  = let scalarArgs
-          = catMaybes
-              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("out_dtype",) . showValue <$>
-                 (args !? #out_dtype ::
-                    Maybe
-                      (Maybe
-                         (EnumType
-                            '["float16", "float32", "float64", "int32", "int64", "int8"]))),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "norm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-norm_upd ::
-         forall args . Fullfilled "norm(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "norm(ndarray)" args -> IO ()
-norm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("out_dtype",) . showValue <$>
-                 (args !? #out_dtype ::
-                    Maybe
-                      (Maybe
-                         (EnumType
-                            '["float16", "float32", "float64", "int32", "int64", "int8"]))),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "norm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_norm(ndarray)" = '[]
-
-_backward_norm ::
-               forall args . Fullfilled "_backward_norm(ndarray)" args =>
-                 ArgsHMap "_backward_norm(ndarray)" args -> IO [NDArrayHandle]
-_backward_norm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_norm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_norm_upd ::
-                   forall args . Fullfilled "_backward_norm(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_norm(ndarray)" args -> IO ()
-_backward_norm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_norm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argmax(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-argmax ::
-       forall args . Fullfilled "argmax(ndarray)" args =>
-         ArgsHMap "argmax(ndarray)" args -> IO [NDArrayHandle]
-argmax args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argmax_upd ::
-           forall args . Fullfilled "argmax(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "argmax(ndarray)" args -> IO ()
-argmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argmin(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-argmin ::
-       forall args . Fullfilled "argmin(ndarray)" args =>
-         ArgsHMap "argmin(ndarray)" args -> IO [NDArrayHandle]
-argmin args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argmin_upd ::
-           forall args . Fullfilled "argmin(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "argmin(ndarray)" args -> IO ()
-argmin_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argmax_channel(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-argmax_channel ::
-               forall args . Fullfilled "argmax_channel(ndarray)" args =>
-                 ArgsHMap "argmax_channel(ndarray)" args -> IO [NDArrayHandle]
-argmax_channel args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax_channel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argmax_channel_upd ::
-                   forall args . Fullfilled "argmax_channel(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "argmax_channel(ndarray)" args -> IO ()
-argmax_channel_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax_channel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "pick(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("mode", AttrOpt (EnumType '["clip", "wrap"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("index", AttrOpt NDArrayHandle)]
-
-pick ::
-     forall args . Fullfilled "pick(ndarray)" args =>
-       ArgsHMap "pick(ndarray)" args -> IO [NDArrayHandle]
-pick args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-pick_upd ::
-         forall args . Fullfilled "pick(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "pick(ndarray)" args -> IO ()
-pick_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_pick(ndarray)" = '[]
-
-_backward_pick ::
-               forall args . Fullfilled "_backward_pick(ndarray)" args =>
-                 ArgsHMap "_backward_pick(ndarray)" args -> IO [NDArrayHandle]
-_backward_pick args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_pick_upd ::
-                   forall args . Fullfilled "_backward_pick(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_pick(ndarray)" args -> IO ()
-_backward_pick_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_pick"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sparse_retain(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("indices", AttrOpt NDArrayHandle)]
-
-_sparse_retain ::
-               forall args . Fullfilled "_sparse_retain(ndarray)" args =>
-                 ArgsHMap "_sparse_retain(ndarray)" args -> IO [NDArrayHandle]
-_sparse_retain args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sparse_retain_upd ::
-                   forall args . Fullfilled "_sparse_retain(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_sparse_retain(ndarray)" args -> IO ()
-_sparse_retain_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("indices",) <$> (args !? #indices :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sparse_retain(ndarray)" =
-     '[]
-
-_backward_sparse_retain ::
-                        forall args . Fullfilled "_backward_sparse_retain(ndarray)" args =>
-                          ArgsHMap "_backward_sparse_retain(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_sparse_retain args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sparse_retain_upd ::
-                            forall args . Fullfilled "_backward_sparse_retain(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_sparse_retain(ndarray)" args -> IO ()
-_backward_sparse_retain_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sparse_retain"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_where(ndarray)" =
-     '[ '("condition", AttrOpt NDArrayHandle),
-        '("x", AttrOpt NDArrayHandle), '("y", AttrOpt NDArrayHandle)]
-
-_where ::
-       forall args . Fullfilled "_where(ndarray)" args =>
-         ArgsHMap "_where(ndarray)" args -> IO [NDArrayHandle]
-_where args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle),
-               ("x",) <$> (args !? #x :: Maybe NDArrayHandle),
-               ("y",) <$> (args !? #y :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_where_upd ::
-           forall args . Fullfilled "_where(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "_where(ndarray)" args -> IO ()
-_where_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("condition",) <$> (args !? #condition :: Maybe NDArrayHandle),
-               ("x",) <$> (args !? #x :: Maybe NDArrayHandle),
-               ("y",) <$> (args !? #y :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_where(ndarray)" = '[]
-
-_backward_where ::
-                forall args . Fullfilled "_backward_where(ndarray)" args =>
-                  ArgsHMap "_backward_where(ndarray)" args -> IO [NDArrayHandle]
-_backward_where args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_where_upd ::
-                    forall args . Fullfilled "_backward_where(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_where(ndarray)" args -> IO ()
-_backward_where_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_where"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "diag(ndarray)" =
-     '[ '("k", AttrOpt Int), '("axis1", AttrOpt Int),
-        '("axis2", AttrOpt Int), '("data", AttrOpt NDArrayHandle)]
-
-diag ::
-     forall args . Fullfilled "diag(ndarray)" args =>
-       ArgsHMap "diag(ndarray)" args -> IO [NDArrayHandle]
-diag args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int),
-               ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "diag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-diag_upd ::
-         forall args . Fullfilled "diag(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "diag(ndarray)" args -> IO ()
-diag_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int),
-               ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "diag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_diag(ndarray)" = '[]
-
-_backward_diag ::
-               forall args . Fullfilled "_backward_diag(ndarray)" args =>
-                 ArgsHMap "_backward_diag(ndarray)" args -> IO [NDArrayHandle]
-_backward_diag args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_diag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_diag_upd ::
-                   forall args . Fullfilled "_backward_diag(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_diag(ndarray)" args -> IO ()
-_backward_diag_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_diag"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_maximum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_maximum_scalar ::
-                forall args . Fullfilled "_maximum_scalar(ndarray)" args =>
-                  ArgsHMap "_maximum_scalar(ndarray)" args -> IO [NDArrayHandle]
-_maximum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_maximum_scalar_upd ::
-                    forall args . Fullfilled "_maximum_scalar(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_maximum_scalar(ndarray)" args -> IO ()
-_maximum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_maximum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_maximum_scalar ::
-                         forall args .
-                           Fullfilled "_backward_maximum_scalar(ndarray)" args =>
-                           ArgsHMap "_backward_maximum_scalar(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_maximum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_maximum_scalar_upd ::
-                             forall args .
-                               Fullfilled "_backward_maximum_scalar(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_maximum_scalar(ndarray)" args -> IO ()
-_backward_maximum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_minimum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_minimum_scalar ::
-                forall args . Fullfilled "_minimum_scalar(ndarray)" args =>
-                  ArgsHMap "_minimum_scalar(ndarray)" args -> IO [NDArrayHandle]
-_minimum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_minimum_scalar_upd ::
-                    forall args . Fullfilled "_minimum_scalar(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_minimum_scalar(ndarray)" args -> IO ()
-_minimum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_minimum_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_minimum_scalar ::
-                         forall args .
-                           Fullfilled "_backward_minimum_scalar(ndarray)" args =>
-                           ArgsHMap "_backward_minimum_scalar(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_minimum_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_minimum_scalar_upd ::
-                             forall args .
-                               Fullfilled "_backward_minimum_scalar(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_minimum_scalar(ndarray)" args -> IO ()
-_backward_minimum_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_power_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_power_scalar ::
-              forall args . Fullfilled "_power_scalar(ndarray)" args =>
-                ArgsHMap "_power_scalar(ndarray)" args -> IO [NDArrayHandle]
-_power_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_power_scalar_upd ::
-                  forall args . Fullfilled "_power_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_power_scalar(ndarray)" args -> IO ()
-_power_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_power_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_power_scalar ::
-                       forall args . Fullfilled "_backward_power_scalar(ndarray)" args =>
-                         ArgsHMap "_backward_power_scalar(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_power_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_power_scalar_upd ::
-                           forall args . Fullfilled "_backward_power_scalar(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_power_scalar(ndarray)" args -> IO ()
-_backward_power_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rpower_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_rpower_scalar ::
-               forall args . Fullfilled "_rpower_scalar(ndarray)" args =>
-                 ArgsHMap "_rpower_scalar(ndarray)" args -> IO [NDArrayHandle]
-_rpower_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_rpower_scalar_upd ::
-                   forall args . Fullfilled "_rpower_scalar(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_rpower_scalar(ndarray)" args -> IO ()
-_rpower_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_rpower_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_rpower_scalar ::
-                        forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args =>
-                          ArgsHMap "_backward_rpower_scalar(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_rpower_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_rpower_scalar_upd ::
-                            forall args . Fullfilled "_backward_rpower_scalar(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_rpower_scalar(ndarray)" args -> IO ()
-_backward_rpower_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rpower_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_hypot_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_hypot_scalar ::
-              forall args . Fullfilled "_hypot_scalar(ndarray)" args =>
-                ArgsHMap "_hypot_scalar(ndarray)" args -> IO [NDArrayHandle]
-_hypot_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_hypot_scalar_upd ::
-                  forall args . Fullfilled "_hypot_scalar(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_hypot_scalar(ndarray)" args -> IO ()
-_hypot_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_hypot_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_hypot_scalar ::
-                       forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args =>
-                         ArgsHMap "_backward_hypot_scalar(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_hypot_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_hypot_scalar_upd ::
-                           forall args . Fullfilled "_backward_hypot_scalar(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_hypot_scalar(ndarray)" args -> IO ()
-_backward_hypot_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "smooth_l1(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-smooth_l1 ::
-          forall args . Fullfilled "smooth_l1(ndarray)" args =>
-            ArgsHMap "smooth_l1(ndarray)" args -> IO [NDArrayHandle]
-smooth_l1 args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-smooth_l1_upd ::
-              forall args . Fullfilled "smooth_l1(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "smooth_l1(ndarray)" args -> IO ()
-smooth_l1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_smooth_l1(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_smooth_l1 ::
-                    forall args . Fullfilled "_backward_smooth_l1(ndarray)" args =>
-                      ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO [NDArrayHandle]
-_backward_smooth_l1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_smooth_l1_upd ::
-                        forall args . Fullfilled "_backward_smooth_l1(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_smooth_l1(ndarray)" args -> IO ()
-_backward_smooth_l1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_smooth_l1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "topk(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),
-        '("ret_typ",
-          AttrOpt (EnumType '["both", "indices", "mask", "value"])),
-        '("is_ascend", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-topk ::
-     forall args . Fullfilled "topk(ndarray)" args =>
-       ArgsHMap "topk(ndarray)" args -> IO [NDArrayHandle]
-topk args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ret_typ",) . showValue <$>
-                 (args !? #ret_typ ::
-                    Maybe (EnumType '["both", "indices", "mask", "value"])),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-topk_upd ::
-         forall args . Fullfilled "topk(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "topk(ndarray)" args -> IO ()
-topk_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ret_typ",) . showValue <$>
-                 (args !? #ret_typ ::
-                    Maybe (EnumType '["both", "indices", "mask", "value"])),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_topk(ndarray)" = '[]
-
-_backward_topk ::
-               forall args . Fullfilled "_backward_topk(ndarray)" args =>
-                 ArgsHMap "_backward_topk(ndarray)" args -> IO [NDArrayHandle]
-_backward_topk args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_topk_upd ::
-                   forall args . Fullfilled "_backward_topk(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_topk(ndarray)" args -> IO ()
-_backward_topk_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_topk"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sort(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-sort ::
-     forall args . Fullfilled "sort(ndarray)" args =>
-       ArgsHMap "sort(ndarray)" args -> IO [NDArrayHandle]
-sort args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sort_upd ::
-         forall args . Fullfilled "sort(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sort(ndarray)" args -> IO ()
-sort_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "argsort(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-argsort ::
-        forall args . Fullfilled "argsort(ndarray)" args =>
-          ArgsHMap "argsort(ndarray)" args -> IO [NDArrayHandle]
-argsort args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argsort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-argsort_upd ::
-            forall args . Fullfilled "argsort(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "argsort(ndarray)" args -> IO ()
-argsort_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argsort"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Reshape(ndarray)" =
-     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),
-        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Reshape ::
-         forall args . Fullfilled "_Reshape(ndarray)" args =>
-           ArgsHMap "_Reshape(ndarray)" args -> IO [NDArrayHandle]
-_Reshape args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("keep_highest",) . showValue <$>
-                 (args !? #keep_highest :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Reshape"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Reshape_upd ::
-             forall args . Fullfilled "_Reshape(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Reshape(ndarray)" args -> IO ()
-_Reshape_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("keep_highest",) . showValue <$>
-                 (args !? #keep_highest :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Reshape"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Flatten(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_Flatten ::
-         forall args . Fullfilled "_Flatten(ndarray)" args =>
-           ArgsHMap "_Flatten(ndarray)" args -> IO [NDArrayHandle]
-_Flatten args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Flatten"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Flatten_upd ::
-             forall args . Fullfilled "_Flatten(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Flatten(ndarray)" args -> IO ()
-_Flatten_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Flatten"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "transpose(ndarray)" =
-     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-transpose ::
-          forall args . Fullfilled "transpose(ndarray)" args =>
-            ArgsHMap "transpose(ndarray)" args -> IO [NDArrayHandle]
-transpose args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "transpose"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-transpose_upd ::
-              forall args . Fullfilled "transpose(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "transpose(ndarray)" args -> IO ()
-transpose_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "transpose"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "expand_dims(ndarray)" =
-     '[ '("axis", AttrReq Int), '("data", AttrOpt NDArrayHandle)]
-
-expand_dims ::
-            forall args . Fullfilled "expand_dims(ndarray)" args =>
-              ArgsHMap "expand_dims(ndarray)" args -> IO [NDArrayHandle]
-expand_dims args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expand_dims"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-expand_dims_upd ::
-                forall args . Fullfilled "expand_dims(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "expand_dims(ndarray)" args -> IO ()
-expand_dims_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expand_dims"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "slice(ndarray)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-slice ::
-      forall args . Fullfilled "slice(ndarray)" args =>
-        ArgsHMap "slice(ndarray)" args -> IO [NDArrayHandle]
-slice args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-slice_upd ::
-          forall args . Fullfilled "slice(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "slice(ndarray)" args -> IO ()
-slice_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_slice(ndarray)" = '[]
-
-_backward_slice ::
-                forall args . Fullfilled "_backward_slice(ndarray)" args =>
-                  ArgsHMap "_backward_slice(ndarray)" args -> IO [NDArrayHandle]
-_backward_slice args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_slice_upd ::
-                    forall args . Fullfilled "_backward_slice(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_slice(ndarray)" args -> IO ()
-_backward_slice_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_slice_assign(ndarray)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_slice_assign ::
-              forall args . Fullfilled "_slice_assign(ndarray)" args =>
-                ArgsHMap "_slice_assign(ndarray)" args -> IO [NDArrayHandle]
-_slice_assign args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_slice_assign_upd ::
-                  forall args . Fullfilled "_slice_assign(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_slice_assign(ndarray)" args -> IO ()
-_slice_assign_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_slice_assign_scalar(ndarray)" =
-     '[ '("scalar", AttrOpt Double), '("begin", AttrReq [Int]),
-        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_slice_assign_scalar ::
-                     forall args . Fullfilled "_slice_assign_scalar(ndarray)" args =>
-                       ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO [NDArrayHandle]
-_slice_assign_scalar args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_slice_assign_scalar_upd ::
-                         forall args . Fullfilled "_slice_assign_scalar(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_slice_assign_scalar(ndarray)" args -> IO ()
-_slice_assign_scalar_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign_scalar"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "slice_axis(ndarray)" =
-     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),
-        '("end", AttrReq (Maybe Int)), '("data", AttrOpt NDArrayHandle)]
-
-slice_axis ::
-           forall args . Fullfilled "slice_axis(ndarray)" args =>
-             ArgsHMap "slice_axis(ndarray)" args -> IO [NDArrayHandle]
-slice_axis args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),
-               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-slice_axis_upd ::
-               forall args . Fullfilled "slice_axis(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "slice_axis(ndarray)" args -> IO ()
-slice_axis_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),
-               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_slice_axis(ndarray)" = '[]
-
-_backward_slice_axis ::
-                     forall args . Fullfilled "_backward_slice_axis(ndarray)" args =>
-                       ArgsHMap "_backward_slice_axis(ndarray)" args -> IO [NDArrayHandle]
-_backward_slice_axis args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_slice_axis_upd ::
-                         forall args . Fullfilled "_backward_slice_axis(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_slice_axis(ndarray)" args -> IO ()
-_backward_slice_axis_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_axis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "slice_like(ndarray)" =
-     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle),
-        '("shape_like", AttrOpt NDArrayHandle)]
-
-slice_like ::
-           forall args . Fullfilled "slice_like(ndarray)" args =>
-             ArgsHMap "slice_like(ndarray)" args -> IO [NDArrayHandle]
-slice_like args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-slice_like_upd ::
-               forall args . Fullfilled "slice_like(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "slice_like(ndarray)" args -> IO ()
-slice_like_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("shape_like",) <$> (args !? #shape_like :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_slice_like(ndarray)" = '[]
-
-_backward_slice_like ::
-                     forall args . Fullfilled "_backward_slice_like(ndarray)" args =>
-                       ArgsHMap "_backward_slice_like(ndarray)" args -> IO [NDArrayHandle]
-_backward_slice_like args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_slice_like_upd ::
-                         forall args . Fullfilled "_backward_slice_like(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_slice_like(ndarray)" args -> IO ()
-_backward_slice_like_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_like"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "clip(ndarray)" =
-     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-clip ::
-     forall args . Fullfilled "clip(ndarray)" args =>
-       ArgsHMap "clip(ndarray)" args -> IO [NDArrayHandle]
-clip args
-  = let scalarArgs
-          = catMaybes
-              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),
-               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-clip_upd ::
-         forall args . Fullfilled "clip(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "clip(ndarray)" args -> IO ()
-clip_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),
-               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_clip(ndarray)" = '[]
-
-_backward_clip ::
-               forall args . Fullfilled "_backward_clip(ndarray)" args =>
-                 ArgsHMap "_backward_clip(ndarray)" args -> IO [NDArrayHandle]
-_backward_clip args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_clip_upd ::
-                   forall args . Fullfilled "_backward_clip(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_clip(ndarray)" args -> IO ()
-_backward_clip_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_clip"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "repeat(ndarray)" =
-     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),
-        '("data", AttrOpt NDArrayHandle)]
-
-repeat ::
-       forall args . Fullfilled "repeat(ndarray)" args =>
-         ArgsHMap "repeat(ndarray)" args -> IO [NDArrayHandle]
-repeat args
-  = let scalarArgs
-          = catMaybes
-              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-repeat_upd ::
-           forall args . Fullfilled "repeat(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "repeat(ndarray)" args -> IO ()
-repeat_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_repeat(ndarray)" = '[]
-
-_backward_repeat ::
-                 forall args . Fullfilled "_backward_repeat(ndarray)" args =>
-                   ArgsHMap "_backward_repeat(ndarray)" args -> IO [NDArrayHandle]
-_backward_repeat args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_repeat_upd ::
-                     forall args . Fullfilled "_backward_repeat(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_repeat(ndarray)" args -> IO ()
-_backward_repeat_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_repeat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "tile(ndarray)" =
-     '[ '("reps", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)]
-
-tile ::
-     forall args . Fullfilled "tile(ndarray)" args =>
-       ArgsHMap "tile(ndarray)" args -> IO [NDArrayHandle]
-tile args
-  = let scalarArgs
-          = catMaybes
-              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-tile_upd ::
-         forall args . Fullfilled "tile(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "tile(ndarray)" args -> IO ()
-tile_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_tile(ndarray)" = '[]
-
-_backward_tile ::
-               forall args . Fullfilled "_backward_tile(ndarray)" args =>
-                 ArgsHMap "_backward_tile(ndarray)" args -> IO [NDArrayHandle]
-_backward_tile args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_tile_upd ::
-                   forall args . Fullfilled "_backward_tile(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_tile(ndarray)" args -> IO ()
-_backward_tile_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tile"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "reverse(ndarray)" =
-     '[ '("axis", AttrReq [Int]), '("data", AttrOpt NDArrayHandle)]
-
-reverse ::
-        forall args . Fullfilled "reverse(ndarray)" args =>
-          ArgsHMap "reverse(ndarray)" args -> IO [NDArrayHandle]
-reverse args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-reverse_upd ::
-            forall args . Fullfilled "reverse(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "reverse(ndarray)" args -> IO ()
-reverse_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_reverse(ndarray)" = '[]
-
-_backward_reverse ::
-                  forall args . Fullfilled "_backward_reverse(ndarray)" args =>
-                    ArgsHMap "_backward_reverse(ndarray)" args -> IO [NDArrayHandle]
-_backward_reverse args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_reverse_upd ::
-                      forall args . Fullfilled "_backward_reverse(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_reverse(ndarray)" args -> IO ()
-_backward_reverse_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "stack(ndarray)" =
-     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-stack ::
-      forall args . Fullfilled "stack(ndarray)" args =>
-        ArgsHMap "stack(ndarray)" args -> IO [NDArrayHandle]
-stack args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "stack"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-stack_upd ::
-          forall args . Fullfilled "stack(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "stack(ndarray)" args -> IO ()
-stack_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "stack"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_stack(ndarray)" = '[]
-
-_backward_stack ::
-                forall args . Fullfilled "_backward_stack(ndarray)" args =>
-                  ArgsHMap "_backward_stack(ndarray)" args -> IO [NDArrayHandle]
-_backward_stack args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_stack"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_stack_upd ::
-                    forall args . Fullfilled "_backward_stack(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_backward_stack(ndarray)" args -> IO ()
-_backward_stack_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_stack"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "squeeze(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe [Int])),
-        '("data", AttrOpt [NDArrayHandle])]
-
-squeeze ::
-        forall args . Fullfilled "squeeze(ndarray)" args =>
-          ArgsHMap "squeeze(ndarray)" args -> IO [NDArrayHandle]
-squeeze args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "squeeze"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-squeeze_upd ::
-            forall args . Fullfilled "squeeze(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "squeeze(ndarray)" args -> IO ()
-squeeze_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "squeeze"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_squeeze(ndarray)" = '[]
-
-_backward_squeeze ::
-                  forall args . Fullfilled "_backward_squeeze(ndarray)" args =>
-                    ArgsHMap "_backward_squeeze(ndarray)" args -> IO [NDArrayHandle]
-_backward_squeeze args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_squeeze"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_squeeze_upd ::
-                      forall args . Fullfilled "_backward_squeeze(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_squeeze(ndarray)" args -> IO ()
-_backward_squeeze_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_squeeze"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "depth_to_space(ndarray)" =
-     '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)]
-
-depth_to_space ::
-               forall args . Fullfilled "depth_to_space(ndarray)" args =>
-                 ArgsHMap "depth_to_space(ndarray)" args -> IO [NDArrayHandle]
-depth_to_space args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "depth_to_space"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-depth_to_space_upd ::
-                   forall args . Fullfilled "depth_to_space(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "depth_to_space(ndarray)" args -> IO ()
-depth_to_space_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "depth_to_space"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "space_to_depth(ndarray)" =
-     '[ '("block_size", AttrReq Int), '("data", AttrOpt NDArrayHandle)]
-
-space_to_depth ::
-               forall args . Fullfilled "space_to_depth(ndarray)" args =>
-                 ArgsHMap "space_to_depth(ndarray)" args -> IO [NDArrayHandle]
-space_to_depth args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "space_to_depth"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-space_to_depth_upd ::
-                   forall args . Fullfilled "space_to_depth(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "space_to_depth(ndarray)" args -> IO ()
-space_to_depth_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "space_to_depth"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_split_v2(ndarray)" =
-     '[ '("indices", AttrReq [Int]), '("axis", AttrOpt Int),
-        '("squeeze_axis", AttrOpt Bool), '("sections", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_split_v2 ::
-          forall args . Fullfilled "_split_v2(ndarray)" args =>
-            ArgsHMap "_split_v2(ndarray)" args -> IO [NDArrayHandle]
-_split_v2 args
-  = let scalarArgs
-          = catMaybes
-              [("indices",) . showValue <$> (args !? #indices :: Maybe [Int]),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool),
-               ("sections",) . showValue <$> (args !? #sections :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_split_v2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_split_v2_upd ::
-              forall args . Fullfilled "_split_v2(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_split_v2(ndarray)" args -> IO ()
-_split_v2_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("indices",) . showValue <$> (args !? #indices :: Maybe [Int]),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool),
-               ("sections",) . showValue <$> (args !? #sections :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_split_v2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_split_v2_backward(ndarray)" = '[]
-
-_split_v2_backward ::
-                   forall args . Fullfilled "_split_v2_backward(ndarray)" args =>
-                     ArgsHMap "_split_v2_backward(ndarray)" args -> IO [NDArrayHandle]
-_split_v2_backward args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_split_v2_backward"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_split_v2_backward_upd ::
-                       forall args . Fullfilled "_split_v2_backward(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_split_v2_backward(ndarray)" args -> IO ()
-_split_v2_backward_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_split_v2_backward"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "dot(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),
-        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-dot ::
-    forall args . Fullfilled "dot(ndarray)" args =>
-      ArgsHMap "dot(ndarray)" args -> IO [NDArrayHandle]
-dot args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-dot_upd ::
-        forall args . Fullfilled "dot(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "dot(ndarray)" args -> IO ()
-dot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_dot(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-
-_backward_dot ::
-              forall args . Fullfilled "_backward_dot(ndarray)" args =>
-                ArgsHMap "_backward_dot(ndarray)" args -> IO [NDArrayHandle]
-_backward_dot args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_dot_upd ::
-                  forall args . Fullfilled "_backward_dot(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_dot(ndarray)" args -> IO ()
-_backward_dot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "batch_dot(ndarray)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),
-        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-batch_dot ::
-          forall args . Fullfilled "batch_dot(ndarray)" args =>
-            ArgsHMap "batch_dot(ndarray)" args -> IO [NDArrayHandle]
-batch_dot args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-batch_dot_upd ::
-              forall args . Fullfilled "batch_dot(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "batch_dot(ndarray)" args -> IO ()
-batch_dot_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_batch_dot(ndarray)" = '[]
-
-_backward_batch_dot ::
-                    forall args . Fullfilled "_backward_batch_dot(ndarray)" args =>
-                      ArgsHMap "_backward_batch_dot(ndarray)" args -> IO [NDArrayHandle]
-_backward_batch_dot args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_batch_dot_upd ::
-                        forall args . Fullfilled "_backward_batch_dot(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_batch_dot(ndarray)" args -> IO ()
-_backward_batch_dot_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_batch_dot"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sin(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sin ::
-    forall args . Fullfilled "sin(ndarray)" args =>
-      ArgsHMap "sin(ndarray)" args -> IO [NDArrayHandle]
-sin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sin_upd ::
-        forall args . Fullfilled "sin(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "sin(ndarray)" args -> IO ()
-sin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sin(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sin ::
-              forall args . Fullfilled "_backward_sin(ndarray)" args =>
-                ArgsHMap "_backward_sin(ndarray)" args -> IO [NDArrayHandle]
-_backward_sin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sin_upd ::
-                  forall args . Fullfilled "_backward_sin(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_sin(ndarray)" args -> IO ()
-_backward_sin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cos(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-cos ::
-    forall args . Fullfilled "cos(ndarray)" args =>
-      ArgsHMap "cos(ndarray)" args -> IO [NDArrayHandle]
-cos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cos_upd ::
-        forall args . Fullfilled "cos(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "cos(ndarray)" args -> IO ()
-cos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cos(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_cos ::
-              forall args . Fullfilled "_backward_cos(ndarray)" args =>
-                ArgsHMap "_backward_cos(ndarray)" args -> IO [NDArrayHandle]
-_backward_cos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cos_upd ::
-                  forall args . Fullfilled "_backward_cos(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_cos(ndarray)" args -> IO ()
-_backward_cos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "tan(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-tan ::
-    forall args . Fullfilled "tan(ndarray)" args =>
-      ArgsHMap "tan(ndarray)" args -> IO [NDArrayHandle]
-tan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-tan_upd ::
-        forall args . Fullfilled "tan(ndarray)" args =>
-          [NDArrayHandle] -> ArgsHMap "tan(ndarray)" args -> IO ()
-tan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_tan(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_tan ::
-              forall args . Fullfilled "_backward_tan(ndarray)" args =>
-                ArgsHMap "_backward_tan(ndarray)" args -> IO [NDArrayHandle]
-_backward_tan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_tan_upd ::
-                  forall args . Fullfilled "_backward_tan(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_tan(ndarray)" args -> IO ()
-_backward_tan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arcsin(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arcsin ::
-       forall args . Fullfilled "arcsin(ndarray)" args =>
-         ArgsHMap "arcsin(ndarray)" args -> IO [NDArrayHandle]
-arcsin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arcsin_upd ::
-           forall args . Fullfilled "arcsin(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "arcsin(ndarray)" args -> IO ()
-arcsin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arcsin(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arcsin ::
-                 forall args . Fullfilled "_backward_arcsin(ndarray)" args =>
-                   ArgsHMap "_backward_arcsin(ndarray)" args -> IO [NDArrayHandle]
-_backward_arcsin args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arcsin_upd ::
-                     forall args . Fullfilled "_backward_arcsin(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_arcsin(ndarray)" args -> IO ()
-_backward_arcsin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arccos(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arccos ::
-       forall args . Fullfilled "arccos(ndarray)" args =>
-         ArgsHMap "arccos(ndarray)" args -> IO [NDArrayHandle]
-arccos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arccos_upd ::
-           forall args . Fullfilled "arccos(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "arccos(ndarray)" args -> IO ()
-arccos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arccos(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arccos ::
-                 forall args . Fullfilled "_backward_arccos(ndarray)" args =>
-                   ArgsHMap "_backward_arccos(ndarray)" args -> IO [NDArrayHandle]
-_backward_arccos args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arccos_upd ::
-                     forall args . Fullfilled "_backward_arccos(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_arccos(ndarray)" args -> IO ()
-_backward_arccos_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccos"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arctan(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arctan ::
-       forall args . Fullfilled "arctan(ndarray)" args =>
-         ArgsHMap "arctan(ndarray)" args -> IO [NDArrayHandle]
-arctan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arctan_upd ::
-           forall args . Fullfilled "arctan(ndarray)" args =>
-             [NDArrayHandle] -> ArgsHMap "arctan(ndarray)" args -> IO ()
-arctan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arctan(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arctan ::
-                 forall args . Fullfilled "_backward_arctan(ndarray)" args =>
-                   ArgsHMap "_backward_arctan(ndarray)" args -> IO [NDArrayHandle]
-_backward_arctan args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arctan_upd ::
-                     forall args . Fullfilled "_backward_arctan(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_arctan(ndarray)" args -> IO ()
-_backward_arctan_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctan"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "degrees(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-degrees ::
-        forall args . Fullfilled "degrees(ndarray)" args =>
-          ArgsHMap "degrees(ndarray)" args -> IO [NDArrayHandle]
-degrees args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-degrees_upd ::
-            forall args . Fullfilled "degrees(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "degrees(ndarray)" args -> IO ()
-degrees_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_degrees(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_degrees ::
-                  forall args . Fullfilled "_backward_degrees(ndarray)" args =>
-                    ArgsHMap "_backward_degrees(ndarray)" args -> IO [NDArrayHandle]
-_backward_degrees args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_degrees_upd ::
-                      forall args . Fullfilled "_backward_degrees(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_degrees(ndarray)" args -> IO ()
-_backward_degrees_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_degrees"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "radians(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-radians ::
-        forall args . Fullfilled "radians(ndarray)" args =>
-          ArgsHMap "radians(ndarray)" args -> IO [NDArrayHandle]
-radians args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-radians_upd ::
-            forall args . Fullfilled "radians(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "radians(ndarray)" args -> IO ()
-radians_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_radians(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_radians ::
-                  forall args . Fullfilled "_backward_radians(ndarray)" args =>
-                    ArgsHMap "_backward_radians(ndarray)" args -> IO [NDArrayHandle]
-_backward_radians args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_radians_upd ::
-                      forall args . Fullfilled "_backward_radians(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_radians(ndarray)" args -> IO ()
-_backward_radians_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_radians"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sinh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-sinh ::
-     forall args . Fullfilled "sinh(ndarray)" args =>
-       ArgsHMap "sinh(ndarray)" args -> IO [NDArrayHandle]
-sinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sinh_upd ::
-         forall args . Fullfilled "sinh(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "sinh(ndarray)" args -> IO ()
-sinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_sinh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_sinh ::
-               forall args . Fullfilled "_backward_sinh(ndarray)" args =>
-                 ArgsHMap "_backward_sinh(ndarray)" args -> IO [NDArrayHandle]
-_backward_sinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_sinh_upd ::
-                   forall args . Fullfilled "_backward_sinh(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_sinh(ndarray)" args -> IO ()
-_backward_sinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "cosh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-cosh ::
-     forall args . Fullfilled "cosh(ndarray)" args =>
-       ArgsHMap "cosh(ndarray)" args -> IO [NDArrayHandle]
-cosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-cosh_upd ::
-         forall args . Fullfilled "cosh(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "cosh(ndarray)" args -> IO ()
-cosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cosh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_cosh ::
-               forall args . Fullfilled "_backward_cosh(ndarray)" args =>
-                 ArgsHMap "_backward_cosh(ndarray)" args -> IO [NDArrayHandle]
-_backward_cosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cosh_upd ::
-                   forall args . Fullfilled "_backward_cosh(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cosh(ndarray)" args -> IO ()
-_backward_cosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "tanh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-tanh ::
-     forall args . Fullfilled "tanh(ndarray)" args =>
-       ArgsHMap "tanh(ndarray)" args -> IO [NDArrayHandle]
-tanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-tanh_upd ::
-         forall args . Fullfilled "tanh(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "tanh(ndarray)" args -> IO ()
-tanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_tanh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_tanh ::
-               forall args . Fullfilled "_backward_tanh(ndarray)" args =>
-                 ArgsHMap "_backward_tanh(ndarray)" args -> IO [NDArrayHandle]
-_backward_tanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_tanh_upd ::
-                   forall args . Fullfilled "_backward_tanh(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_tanh(ndarray)" args -> IO ()
-_backward_tanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arcsinh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arcsinh ::
-        forall args . Fullfilled "arcsinh(ndarray)" args =>
-          ArgsHMap "arcsinh(ndarray)" args -> IO [NDArrayHandle]
-arcsinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arcsinh_upd ::
-            forall args . Fullfilled "arcsinh(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "arcsinh(ndarray)" args -> IO ()
-arcsinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arcsinh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arcsinh ::
-                  forall args . Fullfilled "_backward_arcsinh(ndarray)" args =>
-                    ArgsHMap "_backward_arcsinh(ndarray)" args -> IO [NDArrayHandle]
-_backward_arcsinh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arcsinh_upd ::
-                      forall args . Fullfilled "_backward_arcsinh(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_arcsinh(ndarray)" args -> IO ()
-_backward_arcsinh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsinh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arccosh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arccosh ::
-        forall args . Fullfilled "arccosh(ndarray)" args =>
-          ArgsHMap "arccosh(ndarray)" args -> IO [NDArrayHandle]
-arccosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arccosh_upd ::
-            forall args . Fullfilled "arccosh(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "arccosh(ndarray)" args -> IO ()
-arccosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arccosh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arccosh ::
-                  forall args . Fullfilled "_backward_arccosh(ndarray)" args =>
-                    ArgsHMap "_backward_arccosh(ndarray)" args -> IO [NDArrayHandle]
-_backward_arccosh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arccosh_upd ::
-                      forall args . Fullfilled "_backward_arccosh(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_arccosh(ndarray)" args -> IO ()
-_backward_arccosh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccosh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "arctanh(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-arctanh ::
-        forall args . Fullfilled "arctanh(ndarray)" args =>
-          ArgsHMap "arctanh(ndarray)" args -> IO [NDArrayHandle]
-arctanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-arctanh_upd ::
-            forall args . Fullfilled "arctanh(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "arctanh(ndarray)" args -> IO ()
-arctanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_arctanh(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_backward_arctanh ::
-                  forall args . Fullfilled "_backward_arctanh(ndarray)" args =>
-                    ArgsHMap "_backward_arctanh(ndarray)" args -> IO [NDArrayHandle]
-_backward_arctanh args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_arctanh_upd ::
-                      forall args . Fullfilled "_backward_arctanh(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_arctanh(ndarray)" args -> IO ()
-_backward_arctanh_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctanh"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "khatri_rao(ndarray)" =
-     '[ '("args", AttrOpt [NDArrayHandle])]
-
-khatri_rao ::
-           forall args . Fullfilled "khatri_rao(ndarray)" args =>
-             ArgsHMap "khatri_rao(ndarray)" args -> IO [NDArrayHandle]
-khatri_rao args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "khatri_rao"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-khatri_rao_upd ::
-               forall args . Fullfilled "khatri_rao(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "khatri_rao(ndarray)" args -> IO ()
-khatri_rao_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "khatri_rao"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_contrib_group_adagrad_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle),
-        '("history", AttrOpt NDArrayHandle)]
-
-_contrib_group_adagrad_update ::
-                              forall args .
-                                Fullfilled "_contrib_group_adagrad_update(ndarray)" args =>
-                                ArgsHMap "_contrib_group_adagrad_update(ndarray)" args ->
-                                  IO [NDArrayHandle]
-_contrib_group_adagrad_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_group_adagrad_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_group_adagrad_update_upd ::
-                                  forall args .
-                                    Fullfilled "_contrib_group_adagrad_update(ndarray)" args =>
-                                    [NDArrayHandle] ->
-                                      ArgsHMap "_contrib_group_adagrad_update(ndarray)" args ->
-                                        IO ()
-_contrib_group_adagrad_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_group_adagrad_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_getnnz(ndarray)" =
-     '[ '("axis", AttrOpt (Maybe Int)),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_getnnz ::
-                forall args . Fullfilled "_contrib_getnnz(ndarray)" args =>
-                  ArgsHMap "_contrib_getnnz(ndarray)" args -> IO [NDArrayHandle]
-_contrib_getnnz args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_getnnz"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_getnnz_upd ::
-                    forall args . Fullfilled "_contrib_getnnz(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_contrib_getnnz(ndarray)" args -> IO ()
-_contrib_getnnz_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_getnnz"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_gradientmultiplier(ndarray)"
-     = '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_contrib_gradientmultiplier ::
-                            forall args .
-                              Fullfilled "_contrib_gradientmultiplier(ndarray)" args =>
-                              ArgsHMap "_contrib_gradientmultiplier(ndarray)" args ->
-                                IO [NDArrayHandle]
-_contrib_gradientmultiplier args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_gradientmultiplier"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_gradientmultiplier_upd ::
-                                forall args .
-                                  Fullfilled "_contrib_gradientmultiplier(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_contrib_gradientmultiplier(ndarray)" args -> IO ()
-_contrib_gradientmultiplier_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_gradientmultiplier"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_contrib_backward_gradientmultiplier(ndarray)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_contrib_backward_gradientmultiplier ::
-                                     forall args .
-                                       Fullfilled "_contrib_backward_gradientmultiplier(ndarray)"
-                                         args =>
-                                       ArgsHMap "_contrib_backward_gradientmultiplier(ndarray)" args
-                                         -> IO [NDArrayHandle]
-_contrib_backward_gradientmultiplier args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_gradientmultiplier"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_backward_gradientmultiplier_upd ::
-                                         forall args .
-                                           Fullfilled
-                                             "_contrib_backward_gradientmultiplier(ndarray)" args =>
-                                           [NDArrayHandle] ->
-                                             ArgsHMap
-                                               "_contrib_backward_gradientmultiplier(ndarray)"
-                                               args
-                                               -> IO ()
-_contrib_backward_gradientmultiplier_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_gradientmultiplier"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_edge_id(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle), '("u", AttrOpt NDArrayHandle),
-        '("v", AttrOpt NDArrayHandle)]
-
-_contrib_edge_id ::
-                 forall args . Fullfilled "_contrib_edge_id(ndarray)" args =>
-                   ArgsHMap "_contrib_edge_id(ndarray)" args -> IO [NDArrayHandle]
-_contrib_edge_id args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("u",) <$> (args !? #u :: Maybe NDArrayHandle),
-               ("v",) <$> (args !? #v :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_edge_id"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_edge_id_upd ::
-                     forall args . Fullfilled "_contrib_edge_id(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_contrib_edge_id(ndarray)" args -> IO ()
-_contrib_edge_id_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("u",) <$> (args !? #u :: Maybe NDArrayHandle),
-               ("v",) <$> (args !? #v :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_edge_id"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_dgl_adjacency(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_contrib_dgl_adjacency ::
-                       forall args . Fullfilled "_contrib_dgl_adjacency(ndarray)" args =>
-                         ArgsHMap "_contrib_dgl_adjacency(ndarray)" args ->
-                           IO [NDArrayHandle]
-_contrib_dgl_adjacency args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dgl_adjacency"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_dgl_adjacency_upd ::
-                           forall args . Fullfilled "_contrib_dgl_adjacency(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_contrib_dgl_adjacency(ndarray)" args -> IO ()
-_contrib_dgl_adjacency_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dgl_adjacency"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_hawkesll(ndarray)" =
-     '[ '("lda", AttrOpt NDArrayHandle),
-        '("alpha", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle),
-        '("state", AttrOpt NDArrayHandle),
-        '("lags", AttrOpt NDArrayHandle),
-        '("marks", AttrOpt NDArrayHandle),
-        '("valid_length", AttrOpt NDArrayHandle),
-        '("max_time", AttrOpt NDArrayHandle)]
-
-_contrib_hawkesll ::
-                  forall args . Fullfilled "_contrib_hawkesll(ndarray)" args =>
-                    ArgsHMap "_contrib_hawkesll(ndarray)" args -> IO [NDArrayHandle]
-_contrib_hawkesll args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lda",) <$> (args !? #lda :: Maybe NDArrayHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),
-               ("lags",) <$> (args !? #lags :: Maybe NDArrayHandle),
-               ("marks",) <$> (args !? #marks :: Maybe NDArrayHandle),
-               ("valid_length",) <$>
-                 (args !? #valid_length :: Maybe NDArrayHandle),
-               ("max_time",) <$> (args !? #max_time :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_hawkesll"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_hawkesll_upd ::
-                      forall args . Fullfilled "_contrib_hawkesll(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_contrib_hawkesll(ndarray)" args -> IO ()
-_contrib_hawkesll_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lda",) <$> (args !? #lda :: Maybe NDArrayHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),
-               ("lags",) <$> (args !? #lags :: Maybe NDArrayHandle),
-               ("marks",) <$> (args !? #marks :: Maybe NDArrayHandle),
-               ("valid_length",) <$>
-                 (args !? #valid_length :: Maybe NDArrayHandle),
-               ("max_time",) <$> (args !? #max_time :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_hawkesll"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_backward_hawkesll(ndarray)" =
-     '[]
-
-_contrib_backward_hawkesll ::
-                           forall args .
-                             Fullfilled "_contrib_backward_hawkesll(ndarray)" args =>
-                             ArgsHMap "_contrib_backward_hawkesll(ndarray)" args ->
-                               IO [NDArrayHandle]
-_contrib_backward_hawkesll args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_hawkesll"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_backward_hawkesll_upd ::
-                               forall args .
-                                 Fullfilled "_contrib_backward_hawkesll(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_contrib_backward_hawkesll(ndarray)" args -> IO ()
-_contrib_backward_hawkesll_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_hawkesll"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_mp_adamw_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("eta", AttrReq Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle),
-        '("var", AttrOpt NDArrayHandle),
-        '("weight32", AttrOpt NDArrayHandle),
-        '("rescale_grad", AttrOpt NDArrayHandle)]
-
-_mp_adamw_update ::
-                 forall args . Fullfilled "_mp_adamw_update(ndarray)" args =>
-                   ArgsHMap "_mp_adamw_update(ndarray)" args -> IO [NDArrayHandle]
-_mp_adamw_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("eta",) . showValue <$> (args !? #eta :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),
-               ("var",) <$> (args !? #var :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle),
-               ("rescale_grad",) <$>
-                 (args !? #rescale_grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mp_adamw_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_mp_adamw_update_upd ::
-                     forall args . Fullfilled "_mp_adamw_update(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_mp_adamw_update(ndarray)" args -> IO ()
-_mp_adamw_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("eta",) . showValue <$> (args !? #eta :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),
-               ("var",) <$> (args !? #var :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle),
-               ("rescale_grad",) <$>
-                 (args !? #rescale_grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mp_adamw_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_adamw_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("eta", AttrReq Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle),
-        '("var", AttrOpt NDArrayHandle),
-        '("rescale_grad", AttrOpt NDArrayHandle)]
-
-_adamw_update ::
-              forall args . Fullfilled "_adamw_update(ndarray)" args =>
-                ArgsHMap "_adamw_update(ndarray)" args -> IO [NDArrayHandle]
-_adamw_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("eta",) . showValue <$> (args !? #eta :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),
-               ("var",) <$> (args !? #var :: Maybe NDArrayHandle),
-               ("rescale_grad",) <$>
-                 (args !? #rescale_grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_adamw_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_adamw_update_upd ::
-                  forall args . Fullfilled "_adamw_update(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_adamw_update(ndarray)" args -> IO ()
-_adamw_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("eta",) . showValue <$> (args !? #eta :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),
-               ("var",) <$> (args !? #var :: Maybe NDArrayHandle),
-               ("rescale_grad",) <$>
-                 (args !? #rescale_grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_adamw_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quadratic(ndarray)" =
-     '[ '("a", AttrOpt Float), '("b", AttrOpt Float),
-        '("c", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_contrib_quadratic ::
-                   forall args . Fullfilled "_contrib_quadratic(ndarray)" args =>
-                     ArgsHMap "_contrib_quadratic(ndarray)" args -> IO [NDArrayHandle]
-_contrib_quadratic args
-  = let scalarArgs
-          = catMaybes
-              [("a",) . showValue <$> (args !? #a :: Maybe Float),
-               ("b",) . showValue <$> (args !? #b :: Maybe Float),
-               ("c",) . showValue <$> (args !? #c :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quadratic"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quadratic_upd ::
-                       forall args . Fullfilled "_contrib_quadratic(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_contrib_quadratic(ndarray)" args -> IO ()
-_contrib_quadratic_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("a",) . showValue <$> (args !? #a :: Maybe Float),
-               ("b",) . showValue <$> (args !? #b :: Maybe Float),
-               ("c",) . showValue <$> (args !? #c :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quadratic"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_backward_quadratic(ndarray)"
-     = '[]
-
-_contrib_backward_quadratic ::
-                            forall args .
-                              Fullfilled "_contrib_backward_quadratic(ndarray)" args =>
-                              ArgsHMap "_contrib_backward_quadratic(ndarray)" args ->
-                                IO [NDArrayHandle]
-_contrib_backward_quadratic args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_quadratic"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_backward_quadratic_upd ::
-                                forall args .
-                                  Fullfilled "_contrib_backward_quadratic(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_contrib_backward_quadratic(ndarray)" args -> IO ()
-_contrib_backward_quadratic_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_quadratic"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_div_sqrt_dim(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_contrib_div_sqrt_dim ::
-                      forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args =>
-                        ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args ->
-                          IO [NDArrayHandle]
-_contrib_div_sqrt_dim args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_div_sqrt_dim_upd ::
-                          forall args . Fullfilled "_contrib_div_sqrt_dim(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_contrib_div_sqrt_dim(ndarray)" args -> IO ()
-_contrib_div_sqrt_dim_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "all_finite(ndarray)" =
-     '[ '("init_output", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-all_finite ::
-           forall args . Fullfilled "all_finite(ndarray)" args =>
-             ArgsHMap "all_finite(ndarray)" args -> IO [NDArrayHandle]
-all_finite args
-  = let scalarArgs
-          = catMaybes
-              [("init_output",) . showValue <$>
-                 (args !? #init_output :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "all_finite"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-all_finite_upd ::
-               forall args . Fullfilled "all_finite(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "all_finite(ndarray)" args -> IO ()
-all_finite_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("init_output",) . showValue <$>
-                 (args !? #init_output :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "all_finite"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "multi_all_finite(ndarray)" =
-     '[ '("num_arrays", AttrOpt Int), '("init_output", AttrOpt Bool),
-        '("data", AttrOpt [NDArrayHandle])]
-
-multi_all_finite ::
-                 forall args . Fullfilled "multi_all_finite(ndarray)" args =>
-                   ArgsHMap "multi_all_finite(ndarray)" args -> IO [NDArrayHandle]
-multi_all_finite args
-  = let scalarArgs
-          = catMaybes
-              [("num_arrays",) . showValue <$>
-                 (args !? #num_arrays :: Maybe Int),
-               ("init_output",) . showValue <$>
-                 (args !? #init_output :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "multi_all_finite"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-multi_all_finite_upd ::
-                     forall args . Fullfilled "multi_all_finite(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "multi_all_finite(ndarray)" args -> IO ()
-multi_all_finite_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_arrays",) . showValue <$>
-                 (args !? #num_arrays :: Maybe Int),
-               ("init_output",) . showValue <$>
-                 (args !? #init_output :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "multi_all_finite"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_index_array(ndarray)" =
-     '[ '("axes", AttrOpt (Maybe [Int])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_index_array ::
-                     forall args . Fullfilled "_contrib_index_array(ndarray)" args =>
-                       ArgsHMap "_contrib_index_array(ndarray)" args -> IO [NDArrayHandle]
-_contrib_index_array args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_index_array"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_index_array_upd ::
-                         forall args . Fullfilled "_contrib_index_array(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_contrib_index_array(ndarray)" args -> IO ()
-_contrib_index_array_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_index_array"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_index_copy(ndarray)" =
-     '[ '("old_tensor", AttrOpt NDArrayHandle),
-        '("index_vector", AttrOpt NDArrayHandle),
-        '("new_tensor", AttrOpt NDArrayHandle)]
-
-_contrib_index_copy ::
-                    forall args . Fullfilled "_contrib_index_copy(ndarray)" args =>
-                      ArgsHMap "_contrib_index_copy(ndarray)" args -> IO [NDArrayHandle]
-_contrib_index_copy args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("old_tensor",) <$> (args !? #old_tensor :: Maybe NDArrayHandle),
-               ("index_vector",) <$>
-                 (args !? #index_vector :: Maybe NDArrayHandle),
-               ("new_tensor",) <$> (args !? #new_tensor :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_index_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_index_copy_upd ::
-                        forall args . Fullfilled "_contrib_index_copy(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_contrib_index_copy(ndarray)" args -> IO ()
-_contrib_index_copy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("old_tensor",) <$> (args !? #old_tensor :: Maybe NDArrayHandle),
-               ("index_vector",) <$>
-                 (args !? #index_vector :: Maybe NDArrayHandle),
-               ("new_tensor",) <$> (args !? #new_tensor :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_index_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_backward_index_copy(ndarray)"
-     = '[]
-
-_contrib_backward_index_copy ::
-                             forall args .
-                               Fullfilled "_contrib_backward_index_copy(ndarray)" args =>
-                               ArgsHMap "_contrib_backward_index_copy(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_contrib_backward_index_copy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_index_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_backward_index_copy_upd ::
-                                 forall args .
-                                   Fullfilled "_contrib_backward_index_copy(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_contrib_backward_index_copy(ndarray)" args -> IO ()
-_contrib_backward_index_copy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_index_copy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_ROIAlign(ndarray)" =
-     '[ '("pooled_size", AttrReq [Int]),
-        '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int),
-        '("position_sensitive", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)]
-
-_contrib_ROIAlign ::
-                  forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args =>
-                    ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO [NDArrayHandle]
-_contrib_ROIAlign args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("sample_ratio",) . showValue <$>
-                 (args !? #sample_ratio :: Maybe Int),
-               ("position_sensitive",) . showValue <$>
-                 (args !? #position_sensitive :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ROIAlign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_ROIAlign_upd ::
-                      forall args . Fullfilled "_contrib_ROIAlign(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_contrib_ROIAlign(ndarray)" args -> IO ()
-_contrib_ROIAlign_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("sample_ratio",) . showValue <$>
-                 (args !? #sample_ratio :: Maybe Int),
-               ("position_sensitive",) . showValue <$>
-                 (args !? #position_sensitive :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ROIAlign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_ROIAlign(ndarray)" = '[]
-
-_backward_ROIAlign ::
-                   forall args . Fullfilled "_backward_ROIAlign(ndarray)" args =>
-                     ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO [NDArrayHandle]
-_backward_ROIAlign args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIAlign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_ROIAlign_upd ::
-                       forall args . Fullfilled "_backward_ROIAlign(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_ROIAlign(ndarray)" args -> IO ()
-_backward_ROIAlign_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIAlign"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_box_nms(ndarray)" =
-     '[ '("overlap_thresh", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),
-        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),
-        '("id_index", AttrOpt Int), '("background_id", AttrOpt Int),
-        '("force_suppress", AttrOpt Bool),
-        '("in_format", AttrOpt (EnumType '["center", "corner"])),
-        '("out_format", AttrOpt (EnumType '["center", "corner"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_box_nms ::
-                 forall args . Fullfilled "_contrib_box_nms(ndarray)" args =>
-                   ArgsHMap "_contrib_box_nms(ndarray)" args -> IO [NDArrayHandle]
-_contrib_box_nms args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_nms"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_box_nms_upd ::
-                     forall args . Fullfilled "_contrib_box_nms(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_contrib_box_nms(ndarray)" args -> IO ()
-_contrib_box_nms_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_nms"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_contrib_box_nms(ndarray)" =
-     '[ '("overlap_thresh", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),
-        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),
-        '("id_index", AttrOpt Int), '("background_id", AttrOpt Int),
-        '("force_suppress", AttrOpt Bool),
-        '("in_format", AttrOpt (EnumType '["center", "corner"])),
-        '("out_format", AttrOpt (EnumType '["center", "corner"]))]
-
-_backward_contrib_box_nms ::
-                          forall args .
-                            Fullfilled "_backward_contrib_box_nms(ndarray)" args =>
-                            ArgsHMap "_backward_contrib_box_nms(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_contrib_box_nms args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_nms"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_box_nms_upd ::
-                              forall args .
-                                Fullfilled "_backward_contrib_box_nms(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_contrib_box_nms(ndarray)" args -> IO ()
-_backward_contrib_box_nms_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_nms"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_box_iou(ndarray)" =
-     '[ '("format", AttrOpt (EnumType '["center", "corner"])),
-        '("lhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-_contrib_box_iou ::
-                 forall args . Fullfilled "_contrib_box_iou(ndarray)" args =>
-                   ArgsHMap "_contrib_box_iou(ndarray)" args -> IO [NDArrayHandle]
-_contrib_box_iou args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_iou"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_box_iou_upd ::
-                     forall args . Fullfilled "_contrib_box_iou(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_contrib_box_iou(ndarray)" args -> IO ()
-_contrib_box_iou_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_iou"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_contrib_box_iou(ndarray)" =
-     '[ '("format", AttrOpt (EnumType '["center", "corner"]))]
-
-_backward_contrib_box_iou ::
-                          forall args .
-                            Fullfilled "_backward_contrib_box_iou(ndarray)" args =>
-                            ArgsHMap "_backward_contrib_box_iou(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_contrib_box_iou args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_iou"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_box_iou_upd ::
-                              forall args .
-                                Fullfilled "_backward_contrib_box_iou(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_contrib_box_iou(ndarray)" args -> IO ()
-_backward_contrib_box_iou_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_iou"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_bipartite_matching(ndarray)"
-     =
-     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),
-        '("topk", AttrOpt Int), '("data", AttrOpt NDArrayHandle)]
-
-_contrib_bipartite_matching ::
-                            forall args .
-                              Fullfilled "_contrib_bipartite_matching(ndarray)" args =>
-                              ArgsHMap "_contrib_bipartite_matching(ndarray)" args ->
-                                IO [NDArrayHandle]
-_contrib_bipartite_matching args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_bipartite_matching"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_bipartite_matching_upd ::
-                                forall args .
-                                  Fullfilled "_contrib_bipartite_matching(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_contrib_bipartite_matching(ndarray)" args -> IO ()
-_contrib_bipartite_matching_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_bipartite_matching"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_contrib_bipartite_matching(ndarray)" =
-     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),
-        '("topk", AttrOpt Int)]
-
-_backward_contrib_bipartite_matching ::
-                                     forall args .
-                                       Fullfilled "_backward_contrib_bipartite_matching(ndarray)"
-                                         args =>
-                                       ArgsHMap "_backward_contrib_bipartite_matching(ndarray)" args
-                                         -> IO [NDArrayHandle]
-_backward_contrib_bipartite_matching args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_bipartite_matching_upd ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward_contrib_bipartite_matching(ndarray)" args =>
-                                           [NDArrayHandle] ->
-                                             ArgsHMap
-                                               "_backward_contrib_bipartite_matching(ndarray)"
-                                               args
-                                               -> IO ()
-_backward_contrib_bipartite_matching_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_BilinearResize2D(ndarray)" =
-     '[ '("height", AttrOpt Int), '("width", AttrOpt Int),
-        '("scale_height", AttrOpt (Maybe Float)),
-        '("scale_width", AttrOpt (Maybe Float)),
-        '("mode",
-          AttrOpt
-            (EnumType
-               '["like", "odd_scale", "size", "to_even_down", "to_even_up",
-                 "to_odd_down", "to_odd_up"])),
-        '("data", AttrOpt NDArrayHandle), '("like", AttrOpt NDArrayHandle)]
-
-_contrib_BilinearResize2D ::
-                          forall args .
-                            Fullfilled "_contrib_BilinearResize2D(ndarray)" args =>
-                            ArgsHMap "_contrib_BilinearResize2D(ndarray)" args ->
-                              IO [NDArrayHandle]
-_contrib_BilinearResize2D args
-  = let scalarArgs
-          = catMaybes
-              [("height",) . showValue <$> (args !? #height :: Maybe Int),
-               ("width",) . showValue <$> (args !? #width :: Maybe Int),
-               ("scale_height",) . showValue <$>
-                 (args !? #scale_height :: Maybe (Maybe Float)),
-               ("scale_width",) . showValue <$>
-                 (args !? #scale_width :: Maybe (Maybe Float)),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe
-                      (EnumType
-                         '["like", "odd_scale", "size", "to_even_down", "to_even_up",
-                           "to_odd_down", "to_odd_up"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("like",) <$> (args !? #like :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_BilinearResize2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_BilinearResize2D_upd ::
-                              forall args .
-                                Fullfilled "_contrib_BilinearResize2D(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_contrib_BilinearResize2D(ndarray)" args -> IO ()
-_contrib_BilinearResize2D_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("height",) . showValue <$> (args !? #height :: Maybe Int),
-               ("width",) . showValue <$> (args !? #width :: Maybe Int),
-               ("scale_height",) . showValue <$>
-                 (args !? #scale_height :: Maybe (Maybe Float)),
-               ("scale_width",) . showValue <$>
-                 (args !? #scale_width :: Maybe (Maybe Float)),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe
-                      (EnumType
-                         '["like", "odd_scale", "size", "to_even_down", "to_even_up",
-                           "to_odd_down", "to_odd_up"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("like",) <$> (args !? #like :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_BilinearResize2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_contrib_BilinearResize2D(ndarray)" = '[]
-
-_backward_contrib_BilinearResize2D ::
-                                   forall args .
-                                     Fullfilled "_backward_contrib_BilinearResize2D(ndarray)"
-                                       args =>
-                                     ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)" args ->
-                                       IO [NDArrayHandle]
-_backward_contrib_BilinearResize2D args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_BilinearResize2D_upd ::
-                                       forall args .
-                                         Fullfilled "_backward_contrib_BilinearResize2D(ndarray)"
-                                           args =>
-                                         [NDArrayHandle] ->
-                                           ArgsHMap "_backward_contrib_BilinearResize2D(ndarray)"
-                                             args
-                                             -> IO ()
-_backward_contrib_BilinearResize2D_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_boolean_mask(ndarray)" =
-     '[ '("axis", AttrOpt Int), '("data", AttrOpt NDArrayHandle),
-        '("index", AttrOpt NDArrayHandle)]
-
-_contrib_boolean_mask ::
-                      forall args . Fullfilled "_contrib_boolean_mask(ndarray)" args =>
-                        ArgsHMap "_contrib_boolean_mask(ndarray)" args ->
-                          IO [NDArrayHandle]
-_contrib_boolean_mask args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_boolean_mask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_boolean_mask_upd ::
-                          forall args . Fullfilled "_contrib_boolean_mask(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_contrib_boolean_mask(ndarray)" args -> IO ()
-_contrib_boolean_mask_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("index",) <$> (args !? #index :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_boolean_mask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_contrib_boolean_mask(ndarray)" =
-     '[ '("axis", AttrOpt Int)]
-
-_backward_contrib_boolean_mask ::
-                               forall args .
-                                 Fullfilled "_backward_contrib_boolean_mask(ndarray)" args =>
-                                 ArgsHMap "_backward_contrib_boolean_mask(ndarray)" args ->
-                                   IO [NDArrayHandle]
-_backward_contrib_boolean_mask args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_boolean_mask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_boolean_mask_upd ::
-                                   forall args .
-                                     Fullfilled "_backward_contrib_boolean_mask(ndarray)" args =>
-                                     [NDArrayHandle] ->
-                                       ArgsHMap "_backward_contrib_boolean_mask(ndarray)" args ->
-                                         IO ()
-_backward_contrib_boolean_mask_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_boolean_mask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_SyncBatchNorm(ndarray)" =
-     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int),
-        '("key", AttrReq String), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle),
-        '("moving_mean", AttrOpt NDArrayHandle),
-        '("moving_var", AttrOpt NDArrayHandle)]
-
-_contrib_SyncBatchNorm ::
-                       forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args =>
-                         ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args ->
-                           IO [NDArrayHandle]
-_contrib_SyncBatchNorm args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),
-               ("key",) . showValue <$> (args !? #key :: Maybe String)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_SyncBatchNorm_upd ::
-                           forall args . Fullfilled "_contrib_SyncBatchNorm(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_contrib_SyncBatchNorm(ndarray)" args -> IO ()
-_contrib_SyncBatchNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),
-               ("key",) . showValue <$> (args !? #key :: Maybe String)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_contrib_AdaptiveAvgPooling2D(ndarray)" =
-     '[ '("output_size", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_AdaptiveAvgPooling2D ::
-                              forall args .
-                                Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args =>
-                                ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args ->
-                                  IO [NDArrayHandle]
-_contrib_AdaptiveAvgPooling2D args
-  = let scalarArgs
-          = catMaybes
-              [("output_size",) . showValue <$>
-                 (args !? #output_size :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_AdaptiveAvgPooling2D_upd ::
-                                  forall args .
-                                    Fullfilled "_contrib_AdaptiveAvgPooling2D(ndarray)" args =>
-                                    [NDArrayHandle] ->
-                                      ArgsHMap "_contrib_AdaptiveAvgPooling2D(ndarray)" args ->
-                                        IO ()
-_contrib_AdaptiveAvgPooling2D_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("output_size",) . showValue <$>
-                 (args !? #output_size :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" =
-     '[]
-
-_backward_contrib_AdaptiveAvgPooling2D ::
-                                       forall args .
-                                         Fullfilled
-                                           "_backward_contrib_AdaptiveAvgPooling2D(ndarray)" args =>
-                                         ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"
-                                           args
-                                           -> IO [NDArrayHandle]
-_backward_contrib_AdaptiveAvgPooling2D args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_contrib_AdaptiveAvgPooling2D_upd ::
-                                           forall args .
-                                             Fullfilled
-                                               "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"
-                                               args =>
-                                             [NDArrayHandle] ->
-                                               ArgsHMap
-                                                 "_backward_contrib_AdaptiveAvgPooling2D(ndarray)"
-                                                 args
-                                                 -> IO ()
-_backward_contrib_AdaptiveAvgPooling2D_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_crop(ndarray)" =
-     '[ '("x", AttrReq Int), '("y", AttrReq Int),
-        '("width", AttrReq Int), '("height", AttrReq Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_crop ::
-            forall args . Fullfilled "_image_crop(ndarray)" args =>
-              ArgsHMap "_image_crop(ndarray)" args -> IO [NDArrayHandle]
-_image_crop args
-  = let scalarArgs
-          = catMaybes
-              [("x",) . showValue <$> (args !? #x :: Maybe Int),
-               ("y",) . showValue <$> (args !? #y :: Maybe Int),
-               ("width",) . showValue <$> (args !? #width :: Maybe Int),
-               ("height",) . showValue <$> (args !? #height :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_crop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_crop_upd ::
-                forall args . Fullfilled "_image_crop(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_image_crop(ndarray)" args -> IO ()
-_image_crop_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("x",) . showValue <$> (args !? #x :: Maybe Int),
-               ("y",) . showValue <$> (args !? #y :: Maybe Int),
-               ("width",) . showValue <$> (args !? #width :: Maybe Int),
-               ("height",) . showValue <$> (args !? #height :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_crop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_image_crop(ndarray)" = '[]
-
-_backward_image_crop ::
-                     forall args . Fullfilled "_backward_image_crop(ndarray)" args =>
-                       ArgsHMap "_backward_image_crop(ndarray)" args -> IO [NDArrayHandle]
-_backward_image_crop args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_image_crop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_image_crop_upd ::
-                         forall args . Fullfilled "_backward_image_crop(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_image_crop(ndarray)" args -> IO ()
-_backward_image_crop_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_image_crop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_to_tensor(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_to_tensor ::
-                 forall args . Fullfilled "_image_to_tensor(ndarray)" args =>
-                   ArgsHMap "_image_to_tensor(ndarray)" args -> IO [NDArrayHandle]
-_image_to_tensor args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_to_tensor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_to_tensor_upd ::
-                     forall args . Fullfilled "_image_to_tensor(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_image_to_tensor(ndarray)" args -> IO ()
-_image_to_tensor_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_to_tensor"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_normalize(ndarray)" =
-     '[ '("mean", AttrOpt [Float]), '("std", AttrOpt [Float]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_normalize ::
-                 forall args . Fullfilled "_image_normalize(ndarray)" args =>
-                   ArgsHMap "_image_normalize(ndarray)" args -> IO [NDArrayHandle]
-_image_normalize args
-  = let scalarArgs
-          = catMaybes
-              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),
-               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_normalize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_normalize_upd ::
-                     forall args . Fullfilled "_image_normalize(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_image_normalize(ndarray)" args -> IO ()
-_image_normalize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),
-               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_normalize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_image_normalize(ndarray)" =
-     '[]
-
-_backward_image_normalize ::
-                          forall args .
-                            Fullfilled "_backward_image_normalize(ndarray)" args =>
-                            ArgsHMap "_backward_image_normalize(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_image_normalize args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_image_normalize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_image_normalize_upd ::
-                              forall args .
-                                Fullfilled "_backward_image_normalize(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_image_normalize(ndarray)" args -> IO ()
-_backward_image_normalize_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_image_normalize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_flip_left_right(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_flip_left_right ::
-                       forall args . Fullfilled "_image_flip_left_right(ndarray)" args =>
-                         ArgsHMap "_image_flip_left_right(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_flip_left_right args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_left_right"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_flip_left_right_upd ::
-                           forall args . Fullfilled "_image_flip_left_right(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_flip_left_right(ndarray)" args -> IO ()
-_image_flip_left_right_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_left_right"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_image_random_flip_left_right(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_random_flip_left_right ::
-                              forall args .
-                                Fullfilled "_image_random_flip_left_right(ndarray)" args =>
-                                ArgsHMap "_image_random_flip_left_right(ndarray)" args ->
-                                  IO [NDArrayHandle]
-_image_random_flip_left_right args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_left_right"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_flip_left_right_upd ::
-                                  forall args .
-                                    Fullfilled "_image_random_flip_left_right(ndarray)" args =>
-                                    [NDArrayHandle] ->
-                                      ArgsHMap "_image_random_flip_left_right(ndarray)" args ->
-                                        IO ()
-_image_random_flip_left_right_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_left_right"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_flip_top_bottom(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_flip_top_bottom ::
-                       forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args =>
-                         ArgsHMap "_image_flip_top_bottom(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_flip_top_bottom args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_top_bottom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_flip_top_bottom_upd ::
-                           forall args . Fullfilled "_image_flip_top_bottom(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_flip_top_bottom(ndarray)" args -> IO ()
-_image_flip_top_bottom_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_top_bottom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_image_random_flip_top_bottom(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_image_random_flip_top_bottom ::
-                              forall args .
-                                Fullfilled "_image_random_flip_top_bottom(ndarray)" args =>
-                                ArgsHMap "_image_random_flip_top_bottom(ndarray)" args ->
-                                  IO [NDArrayHandle]
-_image_random_flip_top_bottom args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_top_bottom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_flip_top_bottom_upd ::
-                                  forall args .
-                                    Fullfilled "_image_random_flip_top_bottom(ndarray)" args =>
-                                    [NDArrayHandle] ->
-                                      ArgsHMap "_image_random_flip_top_bottom(ndarray)" args ->
-                                        IO ()
-_image_random_flip_top_bottom_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_top_bottom"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_brightness(ndarray)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_brightness ::
-                         forall args .
-                           Fullfilled "_image_random_brightness(ndarray)" args =>
-                           ArgsHMap "_image_random_brightness(ndarray)" args ->
-                             IO [NDArrayHandle]
-_image_random_brightness args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_brightness"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_brightness_upd ::
-                             forall args .
-                               Fullfilled "_image_random_brightness(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_image_random_brightness(ndarray)" args -> IO ()
-_image_random_brightness_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_brightness"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_contrast(ndarray)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_contrast ::
-                       forall args . Fullfilled "_image_random_contrast(ndarray)" args =>
-                         ArgsHMap "_image_random_contrast(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_random_contrast args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_contrast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_contrast_upd ::
-                           forall args . Fullfilled "_image_random_contrast(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_random_contrast(ndarray)" args -> IO ()
-_image_random_contrast_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_contrast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_saturation(ndarray)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_saturation ::
-                         forall args .
-                           Fullfilled "_image_random_saturation(ndarray)" args =>
-                           ArgsHMap "_image_random_saturation(ndarray)" args ->
-                             IO [NDArrayHandle]
-_image_random_saturation args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_saturation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_saturation_upd ::
-                             forall args .
-                               Fullfilled "_image_random_saturation(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_image_random_saturation(ndarray)" args -> IO ()
-_image_random_saturation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_saturation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_hue(ndarray)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_hue ::
-                  forall args . Fullfilled "_image_random_hue(ndarray)" args =>
-                    ArgsHMap "_image_random_hue(ndarray)" args -> IO [NDArrayHandle]
-_image_random_hue args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_hue"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_hue_upd ::
-                      forall args . Fullfilled "_image_random_hue(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_image_random_hue(ndarray)" args -> IO ()
-_image_random_hue_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_hue"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_color_jitter(ndarray)" =
-     '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float),
-        '("saturation", AttrReq Float), '("hue", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_image_random_color_jitter ::
-                           forall args .
-                             Fullfilled "_image_random_color_jitter(ndarray)" args =>
-                             ArgsHMap "_image_random_color_jitter(ndarray)" args ->
-                               IO [NDArrayHandle]
-_image_random_color_jitter args
-  = let scalarArgs
-          = catMaybes
-              [("brightness",) . showValue <$>
-                 (args !? #brightness :: Maybe Float),
-               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
-               ("saturation",) . showValue <$>
-                 (args !? #saturation :: Maybe Float),
-               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_color_jitter"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_color_jitter_upd ::
-                               forall args .
-                                 Fullfilled "_image_random_color_jitter(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_image_random_color_jitter(ndarray)" args -> IO ()
-_image_random_color_jitter_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("brightness",) . showValue <$>
-                 (args !? #brightness :: Maybe Float),
-               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
-               ("saturation",) . showValue <$>
-                 (args !? #saturation :: Maybe Float),
-               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_color_jitter"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_adjust_lighting(ndarray)" =
-     '[ '("alpha", AttrReq [Float]), '("data", AttrOpt NDArrayHandle)]
-
-_image_adjust_lighting ::
-                       forall args . Fullfilled "_image_adjust_lighting(ndarray)" args =>
-                         ArgsHMap "_image_adjust_lighting(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_adjust_lighting args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_adjust_lighting"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_adjust_lighting_upd ::
-                           forall args . Fullfilled "_image_adjust_lighting(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_adjust_lighting(ndarray)" args -> IO ()
-_image_adjust_lighting_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_adjust_lighting"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_random_lighting(ndarray)" =
-     '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt NDArrayHandle)]
-
-_image_random_lighting ::
-                       forall args . Fullfilled "_image_random_lighting(ndarray)" args =>
-                         ArgsHMap "_image_random_lighting(ndarray)" args ->
-                           IO [NDArrayHandle]
-_image_random_lighting args
-  = let scalarArgs
-          = catMaybes
-              [("alpha_std",) . showValue <$>
-                 (args !? #alpha_std :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_lighting"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_random_lighting_upd ::
-                           forall args . Fullfilled "_image_random_lighting(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_image_random_lighting(ndarray)" args -> IO ()
-_image_random_lighting_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha_std",) . showValue <$>
-                 (args !? #alpha_std :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_lighting"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_image_resize(ndarray)" =
-     '[ '("size", AttrOpt [Int]), '("keep_ratio", AttrOpt Bool),
-        '("interp", AttrOpt Int), '("data", AttrOpt NDArrayHandle)]
-
-_image_resize ::
-              forall args . Fullfilled "_image_resize(ndarray)" args =>
-                ArgsHMap "_image_resize(ndarray)" args -> IO [NDArrayHandle]
-_image_resize args
-  = let scalarArgs
-          = catMaybes
-              [("size",) . showValue <$> (args !? #size :: Maybe [Int]),
-               ("keep_ratio",) . showValue <$>
-                 (args !? #keep_ratio :: Maybe Bool),
-               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_resize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_image_resize_upd ::
-                  forall args . Fullfilled "_image_resize(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_image_resize(ndarray)" args -> IO ()
-_image_resize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("size",) . showValue <$> (args !? #size :: Maybe [Int]),
-               ("keep_ratio",) . showValue <$>
-                 (args !? #keep_ratio :: Maybe Bool),
-               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_resize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "moments(ndarray)" =
-     '[ '("axes", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle)]
-
-moments ::
-        forall args . Fullfilled "moments(ndarray)" args =>
-          ArgsHMap "moments(ndarray)" args -> IO [NDArrayHandle]
-moments args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "moments"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-moments_upd ::
-            forall args . Fullfilled "moments(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "moments(ndarray)" args -> IO ()
-moments_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "moments"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_moments(ndarray)" = '[]
-
-_backward_moments ::
-                  forall args . Fullfilled "_backward_moments(ndarray)" args =>
-                    ArgsHMap "_backward_moments(ndarray)" args -> IO [NDArrayHandle]
-_backward_moments args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_moments"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_moments_upd ::
-                      forall args . Fullfilled "_backward_moments(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_moments(ndarray)" args -> IO ()
-_backward_moments_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_moments"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "softmax(ndarray)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("dtype",
-          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),
-        '("data", AttrOpt NDArrayHandle)]
-
-softmax ::
-        forall args . Fullfilled "softmax(ndarray)" args =>
-          ArgsHMap "softmax(ndarray)" args -> IO [NDArrayHandle]
-softmax args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double)),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-softmax_upd ::
-            forall args . Fullfilled "softmax(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "softmax(ndarray)" args -> IO ()
-softmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double)),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_softmax(ndarray)" =
-     '[ '("args", AttrOpt [NDArrayHandle])]
-
-_backward_softmax ::
-                  forall args . Fullfilled "_backward_softmax(ndarray)" args =>
-                    ArgsHMap "_backward_softmax(ndarray)" args -> IO [NDArrayHandle]
-_backward_softmax args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_backward_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_softmax_upd ::
-                      forall args . Fullfilled "_backward_softmax(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_softmax(ndarray)" args -> IO ()
-_backward_softmax_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_backward_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "softmin(ndarray)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("dtype",
-          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),
-        '("data", AttrOpt NDArrayHandle)]
-
-softmin ::
-        forall args . Fullfilled "softmin(ndarray)" args =>
-          ArgsHMap "softmin(ndarray)" args -> IO [NDArrayHandle]
-softmin args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double)),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-softmin_upd ::
-            forall args . Fullfilled "softmin(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "softmin(ndarray)" args -> IO ()
-softmin_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double)),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_softmin(ndarray)" =
-     '[ '("args", AttrOpt [NDArrayHandle])]
-
-_backward_softmin ::
-                  forall args . Fullfilled "_backward_softmin(ndarray)" args =>
-                    ArgsHMap "_backward_softmin(ndarray)" args -> IO [NDArrayHandle]
-_backward_softmin args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_backward_softmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_softmin_upd ::
-                      forall args . Fullfilled "_backward_softmin(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_softmin(ndarray)" args -> IO ()
-_backward_softmin_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_backward_softmin"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "log_softmax(ndarray)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("dtype",
-          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),
-        '("data", AttrOpt NDArrayHandle)]
-
-log_softmax ::
-            forall args . Fullfilled "log_softmax(ndarray)" args =>
-              ArgsHMap "log_softmax(ndarray)" args -> IO [NDArrayHandle]
-log_softmax args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double)),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-log_softmax_upd ::
-                forall args . Fullfilled "log_softmax(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "log_softmax(ndarray)" args -> IO ()
-log_softmax_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double)),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_log_softmax(ndarray)" =
-     '[ '("args", AttrOpt [NDArrayHandle])]
-
-_backward_log_softmax ::
-                      forall args . Fullfilled "_backward_log_softmax(ndarray)" args =>
-                        ArgsHMap "_backward_log_softmax(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_log_softmax args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_backward_log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_log_softmax_upd ::
-                          forall args . Fullfilled "_backward_log_softmax(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_log_softmax(ndarray)" args -> IO ()
-_backward_log_softmax_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_backward_log_softmax"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Pooling(ndarray)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),
-        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
-        '("pooling_convention",
-          AttrOpt (EnumType '["full", "same", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("p_value", AttrOpt (Maybe Int)),
-        '("count_include_pad", AttrOpt (Maybe Bool)),
-        '("layout",
-          AttrOpt
-            (Maybe
-               (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"]))),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Pooling ::
-         forall args . Fullfilled "_Pooling(ndarray)" args =>
-           ArgsHMap "_Pooling(ndarray)" args -> IO [NDArrayHandle]
-_Pooling args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "same", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool)),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe
-                         (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Pooling_upd ::
-             forall args . Fullfilled "_Pooling(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Pooling(ndarray)" args -> IO ()
-_Pooling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "same", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool)),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe
-                         (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Pooling(ndarray)" = '[]
-
-_backward_Pooling ::
-                  forall args . Fullfilled "_backward_Pooling(ndarray)" args =>
-                    ArgsHMap "_backward_Pooling(ndarray)" args -> IO [NDArrayHandle]
-_backward_Pooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Pooling_upd ::
-                      forall args . Fullfilled "_backward_Pooling(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_Pooling(ndarray)" args -> IO ()
-_backward_Pooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Deconvolution(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_Deconvolution ::
-               forall args . Fullfilled "_Deconvolution(ndarray)" args =>
-                 ArgsHMap "_Deconvolution(ndarray)" args -> IO [NDArrayHandle]
-_Deconvolution args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Deconvolution_upd ::
-                   forall args . Fullfilled "_Deconvolution(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_Deconvolution(ndarray)" args -> IO ()
-_Deconvolution_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Deconvolution(ndarray)" =
-     '[]
-
-_backward_Deconvolution ::
-                        forall args . Fullfilled "_backward_Deconvolution(ndarray)" args =>
-                          ArgsHMap "_backward_Deconvolution(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_Deconvolution args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Deconvolution_upd ::
-                            forall args . Fullfilled "_backward_Deconvolution(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_Deconvolution(ndarray)" args -> IO ()
-_backward_Deconvolution_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Deconvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Activation(ndarray)" =
-     '[ '("act_type",
-          AttrReq
-            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Activation ::
-            forall args . Fullfilled "_Activation(ndarray)" args =>
-              ArgsHMap "_Activation(ndarray)" args -> IO [NDArrayHandle]
-_Activation args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Activation_upd ::
-                forall args . Fullfilled "_Activation(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_Activation(ndarray)" args -> IO ()
-_Activation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Activation(ndarray)" = '[]
-
-_backward_Activation ::
-                     forall args . Fullfilled "_backward_Activation(ndarray)" args =>
-                       ArgsHMap "_backward_Activation(ndarray)" args -> IO [NDArrayHandle]
-_backward_Activation args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Activation_upd ::
-                         forall args . Fullfilled "_backward_Activation(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_Activation(ndarray)" args -> IO ()
-_backward_Activation_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Activation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_UpSampling(ndarray)" =
-     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),
-        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),
-        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),
-        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_UpSampling ::
-            forall args . Fullfilled "_UpSampling(ndarray)" args =>
-              ArgsHMap "_UpSampling(ndarray)" args -> IO [NDArrayHandle]
-_UpSampling args
-  = let scalarArgs
-          = catMaybes
-              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("sample_type",) . showValue <$>
-                 (args !? #sample_type ::
-                    Maybe (EnumType '["bilinear", "nearest"])),
-               ("multi_input_mode",) . showValue <$>
-                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "UpSampling"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_UpSampling_upd ::
-                forall args . Fullfilled "_UpSampling(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_UpSampling(ndarray)" args -> IO ()
-_UpSampling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("sample_type",) . showValue <$>
-                 (args !? #sample_type ::
-                    Maybe (EnumType '["bilinear", "nearest"])),
-               ("multi_input_mode",) . showValue <$>
-                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "UpSampling"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_UpSampling(ndarray)" = '[]
-
-_backward_UpSampling ::
-                     forall args . Fullfilled "_backward_UpSampling(ndarray)" args =>
-                       ArgsHMap "_backward_UpSampling(ndarray)" args -> IO [NDArrayHandle]
-_backward_UpSampling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_UpSampling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_UpSampling_upd ::
-                         forall args . Fullfilled "_backward_UpSampling(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_UpSampling(ndarray)" args -> IO ()
-_backward_UpSampling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_UpSampling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BatchNorm(ndarray)" =
-     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle),
-        '("moving_mean", AttrOpt NDArrayHandle),
-        '("moving_var", AttrOpt NDArrayHandle)]
-
-_BatchNorm ::
-           forall args . Fullfilled "_BatchNorm(ndarray)" args =>
-             ArgsHMap "_BatchNorm(ndarray)" args -> IO [NDArrayHandle]
-_BatchNorm args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BatchNorm_upd ::
-               forall args . Fullfilled "_BatchNorm(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_BatchNorm(ndarray)" args -> IO ()
-_BatchNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe NDArrayHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_BatchNorm(ndarray)" = '[]
-
-_backward_BatchNorm ::
-                    forall args . Fullfilled "_backward_BatchNorm(ndarray)" args =>
-                      ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO [NDArrayHandle]
-_backward_BatchNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_BatchNorm_upd ::
-                        forall args . Fullfilled "_backward_BatchNorm(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_BatchNorm(ndarray)" args -> IO ()
-_backward_BatchNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CTCLoss(ndarray)" =
-     '[ '("use_data_lengths", AttrOpt Bool),
-        '("use_label_lengths", AttrOpt Bool),
-        '("blank_label", AttrOpt (EnumType '["first", "last"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle),
-        '("data_lengths", AttrOpt NDArrayHandle),
-        '("label_lengths", AttrOpt NDArrayHandle)]
-
-_CTCLoss ::
-         forall args . Fullfilled "_CTCLoss(ndarray)" args =>
-           ArgsHMap "_CTCLoss(ndarray)" args -> IO [NDArrayHandle]
-_CTCLoss args
-  = let scalarArgs
-          = catMaybes
-              [("use_data_lengths",) . showValue <$>
-                 (args !? #use_data_lengths :: Maybe Bool),
-               ("use_label_lengths",) . showValue <$>
-                 (args !? #use_label_lengths :: Maybe Bool),
-               ("blank_label",) . showValue <$>
-                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("data_lengths",) <$>
-                 (args !? #data_lengths :: Maybe NDArrayHandle),
-               ("label_lengths",) <$>
-                 (args !? #label_lengths :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CTCLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CTCLoss_upd ::
-             forall args . Fullfilled "_CTCLoss(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_CTCLoss(ndarray)" args -> IO ()
-_CTCLoss_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_data_lengths",) . showValue <$>
-                 (args !? #use_data_lengths :: Maybe Bool),
-               ("use_label_lengths",) . showValue <$>
-                 (args !? #use_label_lengths :: Maybe Bool),
-               ("blank_label",) . showValue <$>
-                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("data_lengths",) <$>
-                 (args !? #data_lengths :: Maybe NDArrayHandle),
-               ("label_lengths",) <$>
-                 (args !? #label_lengths :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CTCLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_ctc_loss(ndarray)" = '[]
-
-_backward_ctc_loss ::
-                   forall args . Fullfilled "_backward_ctc_loss(ndarray)" args =>
-                     ArgsHMap "_backward_ctc_loss(ndarray)" args -> IO [NDArrayHandle]
-_backward_ctc_loss args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ctc_loss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_ctc_loss_upd ::
-                       forall args . Fullfilled "_backward_ctc_loss(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_ctc_loss(ndarray)" args -> IO ()
-_backward_ctc_loss_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ctc_loss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_FullyConnected(ndarray)" =
-     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
-        '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_FullyConnected ::
-                forall args . Fullfilled "_FullyConnected(ndarray)" args =>
-                  ArgsHMap "_FullyConnected(ndarray)" args -> IO [NDArrayHandle]
-_FullyConnected args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_FullyConnected_upd ::
-                    forall args . Fullfilled "_FullyConnected(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_FullyConnected(ndarray)" args -> IO ()
-_FullyConnected_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_FullyConnected(ndarray)" =
-     '[]
-
-_backward_FullyConnected ::
-                         forall args .
-                           Fullfilled "_backward_FullyConnected(ndarray)" args =>
-                           ArgsHMap "_backward_FullyConnected(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_FullyConnected args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_FullyConnected_upd ::
-                             forall args .
-                               Fullfilled "_backward_FullyConnected(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_FullyConnected(ndarray)" args -> IO ()
-_backward_FullyConnected_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_FullyConnected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Convolution(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_Convolution ::
-             forall args . Fullfilled "_Convolution(ndarray)" args =>
-               ArgsHMap "_Convolution(ndarray)" args -> IO [NDArrayHandle]
-_Convolution args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Convolution_upd ::
-                 forall args . Fullfilled "_Convolution(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_Convolution(ndarray)" args -> IO ()
-_Convolution_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Convolution(ndarray)" = '[]
-
-_backward_Convolution ::
-                      forall args . Fullfilled "_backward_Convolution(ndarray)" args =>
-                        ArgsHMap "_backward_Convolution(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_Convolution args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Convolution_upd ::
-                          forall args . Fullfilled "_backward_Convolution(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_Convolution(ndarray)" args -> IO ()
-_backward_Convolution_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LayerNorm(ndarray)" =
-     '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float),
-        '("output_mean_var", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_LayerNorm ::
-           forall args . Fullfilled "_LayerNorm(ndarray)" args =>
-             ArgsHMap "_LayerNorm(ndarray)" args -> IO [NDArrayHandle]
-_LayerNorm args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LayerNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LayerNorm_upd ::
-               forall args . Fullfilled "_LayerNorm(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_LayerNorm(ndarray)" args -> IO ()
-_LayerNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LayerNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_LayerNorm(ndarray)" = '[]
-
-_backward_LayerNorm ::
-                    forall args . Fullfilled "_backward_LayerNorm(ndarray)" args =>
-                      ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO [NDArrayHandle]
-_backward_LayerNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LayerNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_LayerNorm_upd ::
-                        forall args . Fullfilled "_backward_LayerNorm(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_LayerNorm(ndarray)" args -> IO ()
-_backward_LayerNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LayerNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Concat(ndarray)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_Concat ::
-        forall args . Fullfilled "_Concat(ndarray)" args =>
-          ArgsHMap "_Concat(ndarray)" args -> IO [NDArrayHandle]
-_Concat args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_Concat_upd ::
-            forall args . Fullfilled "_Concat(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_Concat(ndarray)" args -> IO ()
-_Concat_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Concat(ndarray)" = '[]
-
-_backward_Concat ::
-                 forall args . Fullfilled "_backward_Concat(ndarray)" args =>
-                   ArgsHMap "_backward_Concat(ndarray)" args -> IO [NDArrayHandle]
-_backward_Concat args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Concat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Concat_upd ::
-                     forall args . Fullfilled "_backward_Concat(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_backward_Concat(ndarray)" args -> IO ()
-_backward_Concat_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Concat"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_rnn_param_concat(ndarray)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_rnn_param_concat ::
-                  forall args . Fullfilled "_rnn_param_concat(ndarray)" args =>
-                    ArgsHMap "_rnn_param_concat(ndarray)" args -> IO [NDArrayHandle]
-_rnn_param_concat args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_rnn_param_concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_rnn_param_concat_upd ::
-                      forall args . Fullfilled "_rnn_param_concat(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_rnn_param_concat(ndarray)" args -> IO ()
-_rnn_param_concat_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_rnn_param_concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SoftmaxActivation(ndarray)" =
-     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_SoftmaxActivation ::
-                   forall args . Fullfilled "_SoftmaxActivation(ndarray)" args =>
-                     ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO [NDArrayHandle]
-_SoftmaxActivation args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SoftmaxActivation_upd ::
-                       forall args . Fullfilled "_SoftmaxActivation(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_SoftmaxActivation(ndarray)" args -> IO ()
-_SoftmaxActivation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SoftmaxActivation(ndarray)"
-     = '[]
-
-_backward_SoftmaxActivation ::
-                            forall args .
-                              Fullfilled "_backward_SoftmaxActivation(ndarray)" args =>
-                              ArgsHMap "_backward_SoftmaxActivation(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward_SoftmaxActivation args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SoftmaxActivation_upd ::
-                                forall args .
-                                  Fullfilled "_backward_SoftmaxActivation(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward_SoftmaxActivation(ndarray)" args -> IO ()
-_backward_SoftmaxActivation_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxActivation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LRN(ndarray)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_LRN ::
-     forall args . Fullfilled "_LRN(ndarray)" args =>
-       ArgsHMap "_LRN(ndarray)" args -> IO [NDArrayHandle]
-_LRN args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),
-               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LRN_upd ::
-         forall args . Fullfilled "_LRN(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_LRN(ndarray)" args -> IO ()
-_LRN_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),
-               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_LRN(ndarray)" = '[]
-
-_backward_LRN ::
-              forall args . Fullfilled "_backward_LRN(ndarray)" args =>
-                ArgsHMap "_backward_LRN(ndarray)" args -> IO [NDArrayHandle]
-_backward_LRN args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_LRN_upd ::
-                  forall args . Fullfilled "_backward_LRN(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_LRN(ndarray)" args -> IO ()
-_backward_LRN_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LRN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Dropout(ndarray)" =
-     '[ '("p", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["always", "training"])),
-        '("axes", AttrOpt [Int]), '("cudnn_off", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Dropout ::
-         forall args . Fullfilled "_Dropout(ndarray)" args =>
-           ArgsHMap "_Dropout(ndarray)" args -> IO [NDArrayHandle]
-_Dropout args
-  = let scalarArgs
-          = catMaybes
-              [("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["always", "training"])),
-               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int]),
-               ("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Dropout_upd ::
-             forall args . Fullfilled "_Dropout(ndarray)" args =>
-               [NDArrayHandle] -> ArgsHMap "_Dropout(ndarray)" args -> IO ()
-_Dropout_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["always", "training"])),
-               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int]),
-               ("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Dropout(ndarray)" = '[]
-
-_backward_Dropout ::
-                  forall args . Fullfilled "_backward_Dropout(ndarray)" args =>
-                    ArgsHMap "_backward_Dropout(ndarray)" args -> IO [NDArrayHandle]
-_backward_Dropout args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Dropout_upd ::
-                      forall args . Fullfilled "_backward_Dropout(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_Dropout(ndarray)" args -> IO ()
-_backward_Dropout_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Dropout"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_contrib_quantized_elemwise_add(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle),
-        '("lhs_min", AttrOpt NDArrayHandle),
-        '("lhs_max", AttrOpt NDArrayHandle),
-        '("rhs_min", AttrOpt NDArrayHandle),
-        '("rhs_max", AttrOpt NDArrayHandle)]
-
-_contrib_quantized_elemwise_add ::
-                                forall args .
-                                  Fullfilled "_contrib_quantized_elemwise_add(ndarray)" args =>
-                                  ArgsHMap "_contrib_quantized_elemwise_add(ndarray)" args ->
-                                    IO [NDArrayHandle]
-_contrib_quantized_elemwise_add args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),
-               ("lhs_min",) <$> (args !? #lhs_min :: Maybe NDArrayHandle),
-               ("lhs_max",) <$> (args !? #lhs_max :: Maybe NDArrayHandle),
-               ("rhs_min",) <$> (args !? #rhs_min :: Maybe NDArrayHandle),
-               ("rhs_max",) <$> (args !? #rhs_max :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_elemwise_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantized_elemwise_add_upd ::
-                                    forall args .
-                                      Fullfilled "_contrib_quantized_elemwise_add(ndarray)" args =>
-                                      [NDArrayHandle] ->
-                                        ArgsHMap "_contrib_quantized_elemwise_add(ndarray)" args ->
-                                          IO ()
-_contrib_quantized_elemwise_add_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle),
-               ("lhs_min",) <$> (args !? #lhs_min :: Maybe NDArrayHandle),
-               ("lhs_max",) <$> (args !? #lhs_max :: Maybe NDArrayHandle),
-               ("rhs_min",) <$> (args !? #rhs_min :: Maybe NDArrayHandle),
-               ("rhs_max",) <$> (args !? #rhs_max :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_elemwise_add"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_dequantize(ndarray)" =
-     '[ '("out_type", AttrOpt (EnumType '["float32"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("min_range", AttrOpt NDArrayHandle),
-        '("max_range", AttrOpt NDArrayHandle)]
-
-_contrib_dequantize ::
-                    forall args . Fullfilled "_contrib_dequantize(ndarray)" args =>
-                      ArgsHMap "_contrib_dequantize(ndarray)" args -> IO [NDArrayHandle]
-_contrib_dequantize args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["float32"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dequantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_dequantize_upd ::
-                        forall args . Fullfilled "_contrib_dequantize(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_contrib_dequantize(ndarray)" args -> IO ()
-_contrib_dequantize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["float32"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dequantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantized_flatten(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("min_data", AttrOpt NDArrayHandle),
-        '("max_data", AttrOpt NDArrayHandle)]
-
-_contrib_quantized_flatten ::
-                           forall args .
-                             Fullfilled "_contrib_quantized_flatten(ndarray)" args =>
-                             ArgsHMap "_contrib_quantized_flatten(ndarray)" args ->
-                               IO [NDArrayHandle]
-_contrib_quantized_flatten args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_flatten"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantized_flatten_upd ::
-                               forall args .
-                                 Fullfilled "_contrib_quantized_flatten(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_contrib_quantized_flatten(ndarray)" args -> IO ()
-_contrib_quantized_flatten_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_flatten"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantized_conv(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle),
-        '("min_data", AttrOpt NDArrayHandle),
-        '("max_data", AttrOpt NDArrayHandle),
-        '("min_weight", AttrOpt NDArrayHandle),
-        '("max_weight", AttrOpt NDArrayHandle),
-        '("min_bias", AttrOpt NDArrayHandle),
-        '("max_bias", AttrOpt NDArrayHandle)]
-
-_contrib_quantized_conv ::
-                        forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args =>
-                          ArgsHMap "_contrib_quantized_conv(ndarray)" args ->
-                            IO [NDArrayHandle]
-_contrib_quantized_conv args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_conv"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantized_conv_upd ::
-                            forall args . Fullfilled "_contrib_quantized_conv(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_contrib_quantized_conv(ndarray)" args -> IO ()
-_contrib_quantized_conv_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_conv"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_contrib_quantized_fully_connected(ndarray)" =
-     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
-        '("flatten", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle),
-        '("min_data", AttrOpt NDArrayHandle),
-        '("max_data", AttrOpt NDArrayHandle),
-        '("min_weight", AttrOpt NDArrayHandle),
-        '("max_weight", AttrOpt NDArrayHandle),
-        '("min_bias", AttrOpt NDArrayHandle),
-        '("max_bias", AttrOpt NDArrayHandle)]
-
-_contrib_quantized_fully_connected ::
-                                   forall args .
-                                     Fullfilled "_contrib_quantized_fully_connected(ndarray)"
-                                       args =>
-                                     ArgsHMap "_contrib_quantized_fully_connected(ndarray)" args ->
-                                       IO [NDArrayHandle]
-_contrib_quantized_fully_connected args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantized_fully_connected_upd ::
-                                       forall args .
-                                         Fullfilled "_contrib_quantized_fully_connected(ndarray)"
-                                           args =>
-                                         [NDArrayHandle] ->
-                                           ArgsHMap "_contrib_quantized_fully_connected(ndarray)"
-                                             args
-                                             -> IO ()
-_contrib_quantized_fully_connected_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe NDArrayHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe NDArrayHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe NDArrayHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantized_pooling(ndarray)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),
-        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
-        '("pooling_convention",
-          AttrOpt (EnumType '["full", "same", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("p_value", AttrOpt (Maybe Int)),
-        '("count_include_pad", AttrOpt (Maybe Bool)),
-        '("layout",
-          AttrOpt
-            (Maybe
-               (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("min_data", AttrOpt NDArrayHandle),
-        '("max_data", AttrOpt NDArrayHandle)]
-
-_contrib_quantized_pooling ::
-                           forall args .
-                             Fullfilled "_contrib_quantized_pooling(ndarray)" args =>
-                             ArgsHMap "_contrib_quantized_pooling(ndarray)" args ->
-                               IO [NDArrayHandle]
-_contrib_quantized_pooling args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "same", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool)),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe
-                         (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantized_pooling_upd ::
-                               forall args .
-                                 Fullfilled "_contrib_quantized_pooling(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_contrib_quantized_pooling(ndarray)" args -> IO ()
-_contrib_quantized_pooling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "same", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool)),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe
-                         (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_pooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantize_v2(ndarray)" =
-     '[ '("out_type", AttrOpt (EnumType '["auto", "int8", "uint8"])),
-        '("min_calib_range", AttrOpt (Maybe Float)),
-        '("max_calib_range", AttrOpt (Maybe Float)),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_quantize_v2 ::
-                     forall args . Fullfilled "_contrib_quantize_v2(ndarray)" args =>
-                       ArgsHMap "_contrib_quantize_v2(ndarray)" args -> IO [NDArrayHandle]
-_contrib_quantize_v2 args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])),
-               ("min_calib_range",) . showValue <$>
-                 (args !? #min_calib_range :: Maybe (Maybe Float)),
-               ("max_calib_range",) . showValue <$>
-                 (args !? #max_calib_range :: Maybe (Maybe Float))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize_v2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantize_v2_upd ::
-                         forall args . Fullfilled "_contrib_quantize_v2(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_contrib_quantize_v2(ndarray)" args -> IO ()
-_contrib_quantize_v2_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])),
-               ("min_calib_range",) . showValue <$>
-                 (args !? #min_calib_range :: Maybe (Maybe Float)),
-               ("max_calib_range",) . showValue <$>
-                 (args !? #max_calib_range :: Maybe (Maybe Float))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize_v2"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantized_concat(ndarray)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_contrib_quantized_concat ::
-                          forall args .
-                            Fullfilled "_contrib_quantized_concat(ndarray)" args =>
-                            ArgsHMap "_contrib_quantized_concat(ndarray)" args ->
-                              IO [NDArrayHandle]
-_contrib_quantized_concat args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_contrib_quantized_concat_upd ::
-                              forall args .
-                                Fullfilled "_contrib_quantized_concat(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_contrib_quantized_concat(ndarray)" args -> IO ()
-_contrib_quantized_concat_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_concat"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_requantize(ndarray)" =
-     '[ '("out_type", AttrOpt (EnumType '["auto", "int8", "uint8"])),
-        '("min_calib_range", AttrOpt (Maybe Float)),
-        '("max_calib_range", AttrOpt (Maybe Float)),
-        '("data", AttrOpt NDArrayHandle),
-        '("min_range", AttrOpt NDArrayHandle),
-        '("max_range", AttrOpt NDArrayHandle)]
-
-_contrib_requantize ::
-                    forall args . Fullfilled "_contrib_requantize(ndarray)" args =>
-                      ArgsHMap "_contrib_requantize(ndarray)" args -> IO [NDArrayHandle]
-_contrib_requantize args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])),
-               ("min_calib_range",) . showValue <$>
-                 (args !? #min_calib_range :: Maybe (Maybe Float)),
-               ("max_calib_range",) . showValue <$>
-                 (args !? #max_calib_range :: Maybe (Maybe Float))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_requantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_requantize_upd ::
-                        forall args . Fullfilled "_contrib_requantize(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_contrib_requantize(ndarray)" args -> IO ()
-_contrib_requantize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])),
-               ("min_calib_range",) . showValue <$>
-                 (args !? #min_calib_range :: Maybe (Maybe Float)),
-               ("max_calib_range",) . showValue <$>
-                 (args !? #max_calib_range :: Maybe (Maybe Float))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_requantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantized_act(ndarray)" =
-     '[ '("act_type",
-          AttrReq
-            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("min_data", AttrOpt NDArrayHandle),
-        '("max_data", AttrOpt NDArrayHandle)]
-
-_contrib_quantized_act ::
-                       forall args . Fullfilled "_contrib_quantized_act(ndarray)" args =>
-                         ArgsHMap "_contrib_quantized_act(ndarray)" args ->
-                           IO [NDArrayHandle]
-_contrib_quantized_act args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_act"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantized_act_upd ::
-                           forall args . Fullfilled "_contrib_quantized_act(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_contrib_quantized_act(ndarray)" args -> IO ()
-_contrib_quantized_act_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe NDArrayHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_act"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_quantize(ndarray)" =
-     '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])),
-        '("data", AttrOpt NDArrayHandle),
-        '("min_range", AttrOpt NDArrayHandle),
-        '("max_range", AttrOpt NDArrayHandle)]
-
-_contrib_quantize ::
-                  forall args . Fullfilled "_contrib_quantize(ndarray)" args =>
-                    ArgsHMap "_contrib_quantize(ndarray)" args -> IO [NDArrayHandle]
-_contrib_quantize args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_quantize_upd ::
-                      forall args . Fullfilled "_contrib_quantize(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_contrib_quantize(ndarray)" args -> IO ()
-_contrib_quantize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe NDArrayHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvimdecode(ndarray)" =
-     '[ '("flag", AttrOpt Int), '("to_rgb", AttrOpt Bool),
-        '("buf", AttrOpt NDArrayHandle)]
-
-_cvimdecode ::
-            forall args . Fullfilled "_cvimdecode(ndarray)" args =>
-              ArgsHMap "_cvimdecode(ndarray)" args -> IO [NDArrayHandle]
-_cvimdecode args
-  = let scalarArgs
-          = catMaybes
-              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvimdecode_upd ::
-                forall args . Fullfilled "_cvimdecode(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_cvimdecode(ndarray)" args -> IO ()
-_cvimdecode_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("buf",) <$> (args !? #buf :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvimread(ndarray)" =
-     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),
-        '("to_rgb", AttrOpt Bool)]
-
-_cvimread ::
-          forall args . Fullfilled "_cvimread(ndarray)" args =>
-            ArgsHMap "_cvimread(ndarray)" args -> IO [NDArrayHandle]
-_cvimread args
-  = let scalarArgs
-          = catMaybes
-              [("filename",) . showValue <$> (args !? #filename :: Maybe String),
-               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimread"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvimread_upd ::
-              forall args . Fullfilled "_cvimread(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_cvimread(ndarray)" args -> IO ()
-_cvimread_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("filename",) . showValue <$> (args !? #filename :: Maybe String),
-               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimread"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvimresize(ndarray)" =
-     '[ '("w", AttrReq Int), '("h", AttrReq Int),
-        '("interp", AttrOpt Int), '("src", AttrOpt NDArrayHandle)]
-
-_cvimresize ::
-            forall args . Fullfilled "_cvimresize(ndarray)" args =>
-              ArgsHMap "_cvimresize(ndarray)" args -> IO [NDArrayHandle]
-_cvimresize args
-  = let scalarArgs
-          = catMaybes
-              [("w",) . showValue <$> (args !? #w :: Maybe Int),
-               ("h",) . showValue <$> (args !? #h :: Maybe Int),
-               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimresize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvimresize_upd ::
-                forall args . Fullfilled "_cvimresize(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_cvimresize(ndarray)" args -> IO ()
-_cvimresize_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("w",) . showValue <$> (args !? #w :: Maybe Int),
-               ("h",) . showValue <$> (args !? #h :: Maybe Int),
-               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimresize"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_cvcopyMakeBorder(ndarray)" =
-     '[ '("top", AttrReq Int), '("bot", AttrReq Int),
-        '("left", AttrReq Int), '("right", AttrReq Int),
-        '("type", AttrOpt Int), '("value", AttrOpt Double),
-        '("values", AttrOpt [Double]), '("src", AttrOpt NDArrayHandle)]
-
-_cvcopyMakeBorder ::
-                  forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args =>
-                    ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO [NDArrayHandle]
-_cvcopyMakeBorder args
-  = let scalarArgs
-          = catMaybes
-              [("top",) . showValue <$> (args !? #top :: Maybe Int),
-               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),
-               ("left",) . showValue <$> (args !? #left :: Maybe Int),
-               ("right",) . showValue <$> (args !? #right :: Maybe Int),
-               ("type",) . showValue <$> (args !? #type :: Maybe Int),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double),
-               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvcopyMakeBorder"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_cvcopyMakeBorder_upd ::
-                      forall args . Fullfilled "_cvcopyMakeBorder(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_cvcopyMakeBorder(ndarray)" args -> IO ()
-_cvcopyMakeBorder_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("top",) . showValue <$> (args !? #top :: Maybe Int),
-               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),
-               ("left",) . showValue <$> (args !? #left :: Maybe Int),
-               ("right",) . showValue <$> (args !? #right :: Maybe Int),
-               ("type",) . showValue <$> (args !? #type :: Maybe Int),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double),
-               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]
-        tensorArgs
-          = catMaybes [("src",) <$> (args !? #src :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvcopyMakeBorder"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_NoGradient(ndarray)" = '[]
-
-_NoGradient ::
-            forall args . Fullfilled "_NoGradient(ndarray)" args =>
-              ArgsHMap "_NoGradient(ndarray)" args -> IO [NDArrayHandle]
-_NoGradient args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_NoGradient"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_NoGradient_upd ::
-                forall args . Fullfilled "_NoGradient(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_NoGradient(ndarray)" args -> IO ()
-_NoGradient_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_NoGradient"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CachedOp(ndarray)" =
-     '[ '("data", AttrOpt [NDArrayHandle])]
-
-_CachedOp ::
-          forall args . Fullfilled "_CachedOp(ndarray)" args =>
-            ArgsHMap "_CachedOp(ndarray)" args -> IO [NDArrayHandle]
-_CachedOp args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CachedOp_upd ::
-              forall args . Fullfilled "_CachedOp(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_CachedOp(ndarray)" args -> IO ()
-_CachedOp_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_CachedOp(ndarray)" = '[]
-
-_backward_CachedOp ::
-                   forall args . Fullfilled "_backward_CachedOp(ndarray)" args =>
-                     ArgsHMap "_backward_CachedOp(ndarray)" args -> IO [NDArrayHandle]
-_backward_CachedOp args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_CachedOp_upd ::
-                       forall args . Fullfilled "_backward_CachedOp(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_CachedOp(ndarray)" args -> IO ()
-_backward_CachedOp_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CachedOp"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_copyto(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle)]
-
-_copyto ::
-        forall args . Fullfilled "_copyto(ndarray)" args =>
-          ArgsHMap "_copyto(ndarray)" args -> IO [NDArrayHandle]
-_copyto args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copyto"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_copyto_upd ::
-            forall args . Fullfilled "_copyto(ndarray)" args =>
-              [NDArrayHandle] -> ArgsHMap "_copyto(ndarray)" args -> IO ()
-_copyto_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copyto"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "softmax_cross_entropy(ndarray)" =
-     '[ '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-softmax_cross_entropy ::
-                      forall args . Fullfilled "softmax_cross_entropy(ndarray)" args =>
-                        ArgsHMap "softmax_cross_entropy(ndarray)" args ->
-                          IO [NDArrayHandle]
-softmax_cross_entropy args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-softmax_cross_entropy_upd ::
-                          forall args . Fullfilled "softmax_cross_entropy(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "softmax_cross_entropy(ndarray)" args -> IO ()
-softmax_cross_entropy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_softmax_cross_entropy(ndarray)" = '[]
-
-_backward_softmax_cross_entropy ::
-                                forall args .
-                                  Fullfilled "_backward_softmax_cross_entropy(ndarray)" args =>
-                                  ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args ->
-                                    IO [NDArrayHandle]
-_backward_softmax_cross_entropy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_softmax_cross_entropy_upd ::
-                                    forall args .
-                                      Fullfilled "_backward_softmax_cross_entropy(ndarray)" args =>
-                                      [NDArrayHandle] ->
-                                        ArgsHMap "_backward_softmax_cross_entropy(ndarray)" args ->
-                                          IO ()
-_backward_softmax_cross_entropy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_foreach(ndarray)" = '[]
-
-_backward_foreach ::
-                  forall args . Fullfilled "_backward_foreach(ndarray)" args =>
-                    ArgsHMap "_backward_foreach(ndarray)" args -> IO [NDArrayHandle]
-_backward_foreach args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_foreach"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_foreach_upd ::
-                      forall args . Fullfilled "_backward_foreach(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward_foreach(ndarray)" args -> IO ()
-_backward_foreach_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_foreach"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_while_loop(ndarray)" = '[]
-
-_backward_while_loop ::
-                     forall args . Fullfilled "_backward_while_loop(ndarray)" args =>
-                       ArgsHMap "_backward_while_loop(ndarray)" args -> IO [NDArrayHandle]
-_backward_while_loop args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_while_loop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_while_loop_upd ::
-                         forall args . Fullfilled "_backward_while_loop(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_while_loop(ndarray)" args -> IO ()
-_backward_while_loop_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_while_loop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_cond(ndarray)" = '[]
-
-_backward_cond ::
-               forall args . Fullfilled "_backward_cond(ndarray)" args =>
-                 ArgsHMap "_backward_cond(ndarray)" args -> IO [NDArrayHandle]
-_backward_cond args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cond"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_cond_upd ::
-                   forall args . Fullfilled "_backward_cond(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_cond(ndarray)" args -> IO ()
-_backward_cond_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cond"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SoftmaxOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
-        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_SoftmaxOutput ::
-               forall args . Fullfilled "_SoftmaxOutput(ndarray)" args =>
-                 ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO [NDArrayHandle]
-_SoftmaxOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SoftmaxOutput_upd ::
-                   forall args . Fullfilled "_SoftmaxOutput(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_SoftmaxOutput(ndarray)" args -> IO ()
-_SoftmaxOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SoftmaxOutput(ndarray)" =
-     '[]
-
-_backward_SoftmaxOutput ::
-                        forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args =>
-                          ArgsHMap "_backward_SoftmaxOutput(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_SoftmaxOutput args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SoftmaxOutput_upd ::
-                            forall args . Fullfilled "_backward_SoftmaxOutput(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_SoftmaxOutput(ndarray)" args -> IO ()
-_backward_SoftmaxOutput_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LeakyReLU(ndarray)" =
-     '[ '("act_type",
-          AttrOpt
-            (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])),
-        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),
-        '("upper_bound", AttrOpt Float), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle)]
-
-_LeakyReLU ::
-           forall args . Fullfilled "_LeakyReLU(ndarray)" args =>
-             ArgsHMap "_LeakyReLU(ndarray)" args -> IO [NDArrayHandle]
-_LeakyReLU args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])),
-               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),
-               ("lower_bound",) . showValue <$>
-                 (args !? #lower_bound :: Maybe Float),
-               ("upper_bound",) . showValue <$>
-                 (args !? #upper_bound :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LeakyReLU_upd ::
-               forall args . Fullfilled "_LeakyReLU(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_LeakyReLU(ndarray)" args -> IO ()
-_LeakyReLU_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])),
-               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),
-               ("lower_bound",) . showValue <$>
-                 (args !? #lower_bound :: Maybe Float),
-               ("upper_bound",) . showValue <$>
-                 (args !? #upper_bound :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SwapAxis(ndarray)" =
-     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_SwapAxis ::
-          forall args . Fullfilled "_SwapAxis(ndarray)" args =>
-            ArgsHMap "_SwapAxis(ndarray)" args -> IO [NDArrayHandle]
-_SwapAxis args
-  = let scalarArgs
-          = catMaybes
-              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),
-               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SwapAxis_upd ::
-              forall args . Fullfilled "_SwapAxis(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_SwapAxis(ndarray)" args -> IO ()
-_SwapAxis_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),
-               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_IdentityAttachKLSparseReg(ndarray)" =
-     '[ '("sparseness_target", AttrOpt Float),
-        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle)]
-
-_IdentityAttachKLSparseReg ::
-                           forall args .
-                             Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args =>
-                             ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args ->
-                               IO [NDArrayHandle]
-_IdentityAttachKLSparseReg args
-  = let scalarArgs
-          = catMaybes
-              [("sparseness_target",) . showValue <$>
-                 (args !? #sparseness_target :: Maybe Float),
-               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_IdentityAttachKLSparseReg_upd ::
-                               forall args .
-                                 Fullfilled "_IdentityAttachKLSparseReg(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_IdentityAttachKLSparseReg(ndarray)" args -> IO ()
-_IdentityAttachKLSparseReg_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("sparseness_target",) . showValue <$>
-                 (args !? #sparseness_target :: Maybe Float),
-               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SliceChannel(ndarray)" =
-     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),
-        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt NDArrayHandle)]
-
-_SliceChannel ::
-              forall args . Fullfilled "_SliceChannel(ndarray)" args =>
-                ArgsHMap "_SliceChannel(ndarray)" args -> IO [NDArrayHandle]
-_SliceChannel args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SliceChannel_upd ::
-                  forall args . Fullfilled "_SliceChannel(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_SliceChannel(ndarray)" args -> IO ()
-_SliceChannel_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_RNN(ndarray)" =
-     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),
-        '("bidirectional", AttrOpt Bool),
-        '("mode",
-          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),
-        '("projection_size", AttrOpt (Maybe Int)),
-        '("lstm_state_clip_min", AttrOpt (Maybe Double)),
-        '("lstm_state_clip_max", AttrOpt (Maybe Double)),
-        '("lstm_state_clip_nan", AttrOpt Bool),
-        '("use_sequence_length", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle),
-        '("parameters", AttrOpt NDArrayHandle),
-        '("state", AttrOpt NDArrayHandle),
-        '("state_cell", AttrOpt NDArrayHandle),
-        '("sequence_length", AttrOpt NDArrayHandle)]
-
-_RNN ::
-     forall args . Fullfilled "_RNN(ndarray)" args =>
-       ArgsHMap "_RNN(ndarray)" args -> IO [NDArrayHandle]
-_RNN args
-  = let scalarArgs
-          = catMaybes
-              [("state_size",) . showValue <$>
-                 (args !? #state_size :: Maybe Int),
-               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),
-               ("bidirectional",) . showValue <$>
-                 (args !? #bidirectional :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("state_outputs",) . showValue <$>
-                 (args !? #state_outputs :: Maybe Bool),
-               ("projection_size",) . showValue <$>
-                 (args !? #projection_size :: Maybe (Maybe Int)),
-               ("lstm_state_clip_min",) . showValue <$>
-                 (args !? #lstm_state_clip_min :: Maybe (Maybe Double)),
-               ("lstm_state_clip_max",) . showValue <$>
-                 (args !? #lstm_state_clip_max :: Maybe (Maybe Double)),
-               ("lstm_state_clip_nan",) . showValue <$>
-                 (args !? #lstm_state_clip_nan :: Maybe Bool),
-               ("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle),
-               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),
-               ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_RNN_upd ::
-         forall args . Fullfilled "_RNN(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_RNN(ndarray)" args -> IO ()
-_RNN_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("state_size",) . showValue <$>
-                 (args !? #state_size :: Maybe Int),
-               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),
-               ("bidirectional",) . showValue <$>
-                 (args !? #bidirectional :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("state_outputs",) . showValue <$>
-                 (args !? #state_outputs :: Maybe Bool),
-               ("projection_size",) . showValue <$>
-                 (args !? #projection_size :: Maybe (Maybe Int)),
-               ("lstm_state_clip_min",) . showValue <$>
-                 (args !? #lstm_state_clip_min :: Maybe (Maybe Double)),
-               ("lstm_state_clip_max",) . showValue <$>
-                 (args !? #lstm_state_clip_max :: Maybe (Maybe Double)),
-               ("lstm_state_clip_nan",) . showValue <$>
-                 (args !? #lstm_state_clip_nan :: Maybe Bool),
-               ("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("parameters",) <$> (args !? #parameters :: Maybe NDArrayHandle),
-               ("state",) <$> (args !? #state :: Maybe NDArrayHandle),
-               ("state_cell",) <$> (args !? #state_cell :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_RNN(ndarray)" = '[]
-
-_backward_RNN ::
-              forall args . Fullfilled "_backward_RNN(ndarray)" args =>
-                ArgsHMap "_backward_RNN(ndarray)" args -> IO [NDArrayHandle]
-_backward_RNN args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_RNN_upd ::
-                  forall args . Fullfilled "_backward_RNN(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_RNN(ndarray)" args -> IO ()
-_backward_RNN_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_RNN"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Pad(ndarray)" =
-     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),
-        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Pad ::
-     forall args . Fullfilled "_Pad(ndarray)" args =>
-       ArgsHMap "_Pad(ndarray)" args -> IO [NDArrayHandle]
-_Pad args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["constant", "edge", "reflect"])),
-               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),
-               ("constant_value",) . showValue <$>
-                 (args !? #constant_value :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Pad_upd ::
-         forall args . Fullfilled "_Pad(ndarray)" args =>
-           [NDArrayHandle] -> ArgsHMap "_Pad(ndarray)" args -> IO ()
-_Pad_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["constant", "edge", "reflect"])),
-               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),
-               ("constant_value",) . showValue <$>
-                 (args !? #constant_value :: Maybe Double)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BatchNorm_v1(ndarray)" =
-     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool),
-        '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_BatchNorm_v1 ::
-              forall args . Fullfilled "_BatchNorm_v1(ndarray)" args =>
-                ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO [NDArrayHandle]
-_BatchNorm_v1 args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BatchNorm_v1_upd ::
-                  forall args . Fullfilled "_BatchNorm_v1(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_BatchNorm_v1(ndarray)" args -> IO ()
-_BatchNorm_v1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "signsgd_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle)]
-
-signsgd_update ::
-               forall args . Fullfilled "signsgd_update(ndarray)" args =>
-                 ArgsHMap "signsgd_update(ndarray)" args -> IO [NDArrayHandle]
-signsgd_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signsgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-signsgd_update_upd ::
-                   forall args . Fullfilled "signsgd_update(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "signsgd_update(ndarray)" args -> IO ()
-signsgd_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signsgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "signum_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]
-
-signum_update ::
-              forall args . Fullfilled "signum_update(ndarray)" args =>
-                ArgsHMap "signum_update(ndarray)" args -> IO [NDArrayHandle]
-signum_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signum_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-signum_update_upd ::
-                  forall args . Fullfilled "signum_update(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "signum_update(ndarray)" args -> IO ()
-signum_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signum_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "multi_sgd_update(ndarray)" =
-     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-multi_sgd_update ::
-                 forall args . Fullfilled "multi_sgd_update(ndarray)" args =>
-                   ArgsHMap "multi_sgd_update(ndarray)" args -> IO [NDArrayHandle]
-multi_sgd_update args
-  = let scalarArgs
-          = catMaybes
-              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
-               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("num_weights",) . showValue <$>
-                 (args !? #num_weights :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "multi_sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-multi_sgd_update_upd ::
-                     forall args . Fullfilled "multi_sgd_update(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "multi_sgd_update(ndarray)" args -> IO ()
-multi_sgd_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
-               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("num_weights",) . showValue <$>
-                 (args !? #num_weights :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "multi_sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "multi_sgd_mom_update(ndarray)" =
-     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),
-        '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-multi_sgd_mom_update ::
-                     forall args . Fullfilled "multi_sgd_mom_update(ndarray)" args =>
-                       ArgsHMap "multi_sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]
-multi_sgd_mom_update args
-  = let scalarArgs
-          = catMaybes
-              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
-               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("num_weights",) . showValue <$>
-                 (args !? #num_weights :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "multi_sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-multi_sgd_mom_update_upd ::
-                         forall args . Fullfilled "multi_sgd_mom_update(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "multi_sgd_mom_update(ndarray)" args -> IO ()
-multi_sgd_mom_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
-               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("num_weights",) . showValue <$>
-                 (args !? #num_weights :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "multi_sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "multi_mp_sgd_update(ndarray)" =
-     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-multi_mp_sgd_update ::
-                    forall args . Fullfilled "multi_mp_sgd_update(ndarray)" args =>
-                      ArgsHMap "multi_mp_sgd_update(ndarray)" args -> IO [NDArrayHandle]
-multi_mp_sgd_update args
-  = let scalarArgs
-          = catMaybes
-              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
-               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("num_weights",) . showValue <$>
-                 (args !? #num_weights :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "multi_mp_sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-multi_mp_sgd_update_upd ::
-                        forall args . Fullfilled "multi_mp_sgd_update(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "multi_mp_sgd_update(ndarray)" args -> IO ()
-multi_mp_sgd_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
-               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("num_weights",) . showValue <$>
-                 (args !? #num_weights :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "multi_mp_sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "multi_mp_sgd_mom_update(ndarray)" =
-     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),
-        '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
-        '("data", AttrOpt [NDArrayHandle])]
-
-multi_mp_sgd_mom_update ::
-                        forall args . Fullfilled "multi_mp_sgd_mom_update(ndarray)" args =>
-                          ArgsHMap "multi_mp_sgd_mom_update(ndarray)" args ->
-                            IO [NDArrayHandle]
-multi_mp_sgd_mom_update args
-  = let scalarArgs
-          = catMaybes
-              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
-               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("num_weights",) . showValue <$>
-                 (args !? #num_weights :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "multi_mp_sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-multi_mp_sgd_mom_update_upd ::
-                            forall args . Fullfilled "multi_mp_sgd_mom_update(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "multi_mp_sgd_mom_update(ndarray)" args -> IO ()
-multi_mp_sgd_mom_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
-               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("num_weights",) . showValue <$>
-                 (args !? #num_weights :: Maybe Int)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "multi_mp_sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sgd_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle)]
-
-sgd_update ::
-           forall args . Fullfilled "sgd_update(ndarray)" args =>
-             ArgsHMap "sgd_update(ndarray)" args -> IO [NDArrayHandle]
-sgd_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sgd_update_upd ::
-               forall args . Fullfilled "sgd_update(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "sgd_update(ndarray)" args -> IO ()
-sgd_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "sgd_mom_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]
-
-sgd_mom_update ::
-               forall args . Fullfilled "sgd_mom_update(ndarray)" args =>
-                 ArgsHMap "sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]
-sgd_mom_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-sgd_mom_update_upd ::
-                   forall args . Fullfilled "sgd_mom_update(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "sgd_mom_update(ndarray)" args -> IO ()
-sgd_mom_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "mp_sgd_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle),
-        '("weight32", AttrOpt NDArrayHandle)]
-
-mp_sgd_update ::
-              forall args . Fullfilled "mp_sgd_update(ndarray)" args =>
-                ArgsHMap "mp_sgd_update(ndarray)" args -> IO [NDArrayHandle]
-mp_sgd_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-mp_sgd_update_upd ::
-                  forall args . Fullfilled "mp_sgd_update(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "mp_sgd_update(ndarray)" args -> IO ()
-mp_sgd_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "mp_sgd_mom_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle),
-        '("weight32", AttrOpt NDArrayHandle)]
-
-mp_sgd_mom_update ::
-                  forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args =>
-                    ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO [NDArrayHandle]
-mp_sgd_mom_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-mp_sgd_mom_update_upd ::
-                      forall args . Fullfilled "mp_sgd_mom_update(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "mp_sgd_mom_update(ndarray)" args -> IO ()
-mp_sgd_mom_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ftml_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double),
-        '("t", AttrReq Int), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("d", AttrOpt NDArrayHandle),
-        '("v", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle)]
-
-ftml_update ::
-            forall args . Fullfilled "ftml_update(ndarray)" args =>
-              ArgsHMap "ftml_update(ndarray)" args -> IO [NDArrayHandle]
-ftml_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),
-               ("t",) . showValue <$> (args !? #t :: Maybe Int),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("d",) <$> (args !? #d :: Maybe NDArrayHandle),
-               ("v",) <$> (args !? #v :: Maybe NDArrayHandle),
-               ("z",) <$> (args !? #z :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftml_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ftml_update_upd ::
-                forall args . Fullfilled "ftml_update(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "ftml_update(ndarray)" args -> IO ()
-ftml_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),
-               ("t",) . showValue <$> (args !? #t :: Maybe Int),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("d",) <$> (args !? #d :: Maybe NDArrayHandle),
-               ("v",) <$> (args !? #v :: Maybe NDArrayHandle),
-               ("z",) <$> (args !? #z :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftml_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "adam_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mean", AttrOpt NDArrayHandle),
-        '("var", AttrOpt NDArrayHandle)]
-
-adam_update ::
-            forall args . Fullfilled "adam_update(ndarray)" args =>
-              ArgsHMap "adam_update(ndarray)" args -> IO [NDArrayHandle]
-adam_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),
-               ("var",) <$> (args !? #var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "adam_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-adam_update_upd ::
-                forall args . Fullfilled "adam_update(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "adam_update(ndarray)" args -> IO ()
-adam_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mean",) <$> (args !? #mean :: Maybe NDArrayHandle),
-               ("var",) <$> (args !? #var :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "adam_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "nag_mom_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle)]
-
-nag_mom_update ::
-               forall args . Fullfilled "nag_mom_update(ndarray)" args =>
-                 ArgsHMap "nag_mom_update(ndarray)" args -> IO [NDArrayHandle]
-nag_mom_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nag_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-nag_mom_update_upd ::
-                   forall args . Fullfilled "nag_mom_update(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "nag_mom_update(ndarray)" args -> IO ()
-nag_mom_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nag_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "mp_nag_mom_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("mom", AttrOpt NDArrayHandle),
-        '("weight32", AttrOpt NDArrayHandle)]
-
-mp_nag_mom_update ::
-                  forall args . Fullfilled "mp_nag_mom_update(ndarray)" args =>
-                    ArgsHMap "mp_nag_mom_update(ndarray)" args -> IO [NDArrayHandle]
-mp_nag_mom_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_nag_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-mp_nag_mom_update_upd ::
-                      forall args . Fullfilled "mp_nag_mom_update(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "mp_nag_mom_update(ndarray)" args -> IO ()
-mp_nag_mom_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("mom",) <$> (args !? #mom :: Maybe NDArrayHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_nag_mom_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rmsprop_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle)]
-
-rmsprop_update ::
-               forall args . Fullfilled "rmsprop_update(ndarray)" args =>
-                 ArgsHMap "rmsprop_update(ndarray)" args -> IO [NDArrayHandle]
-rmsprop_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmsprop_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rmsprop_update_upd ::
-                   forall args . Fullfilled "rmsprop_update(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "rmsprop_update(ndarray)" args -> IO ()
-rmsprop_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmsprop_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "rmspropalex_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("n", AttrOpt NDArrayHandle),
-        '("g", AttrOpt NDArrayHandle), '("delta", AttrOpt NDArrayHandle)]
-
-rmspropalex_update ::
-                   forall args . Fullfilled "rmspropalex_update(ndarray)" args =>
-                     ArgsHMap "rmspropalex_update(ndarray)" args -> IO [NDArrayHandle]
-rmspropalex_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle),
-               ("g",) <$> (args !? #g :: Maybe NDArrayHandle),
-               ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmspropalex_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-rmspropalex_update_upd ::
-                       forall args . Fullfilled "rmspropalex_update(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "rmspropalex_update(ndarray)" args -> IO ()
-rmspropalex_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle),
-               ("g",) <$> (args !? #g :: Maybe NDArrayHandle),
-               ("delta",) <$> (args !? #delta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmspropalex_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "ftrl_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),
-        '("beta", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle), '("z", AttrOpt NDArrayHandle),
-        '("n", AttrOpt NDArrayHandle)]
-
-ftrl_update ::
-            forall args . Fullfilled "ftrl_update(ndarray)" args =>
-              ArgsHMap "ftrl_update(ndarray)" args -> IO [NDArrayHandle]
-ftrl_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("z",) <$> (args !? #z :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftrl_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-ftrl_update_upd ::
-                forall args . Fullfilled "ftrl_update(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "ftrl_update(ndarray)" args -> IO ()
-ftrl_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("z",) <$> (args !? #z :: Maybe NDArrayHandle),
-               ("n",) <$> (args !? #n :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftrl_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_sparse_adagrad_update(ndarray)" =
-     '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt NDArrayHandle),
-        '("grad", AttrOpt NDArrayHandle),
-        '("history", AttrOpt NDArrayHandle)]
-
-_sparse_adagrad_update ::
-                       forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args =>
-                         ArgsHMap "_sparse_adagrad_update(ndarray)" args ->
-                           IO [NDArrayHandle]
-_sparse_adagrad_update args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_adagrad_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_sparse_adagrad_update_upd ::
-                           forall args . Fullfilled "_sparse_adagrad_update(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_sparse_adagrad_update(ndarray)" args -> IO ()
-_sparse_adagrad_update_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("grad",) <$> (args !? #grad :: Maybe NDArrayHandle),
-               ("history",) <$> (args !? #history :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_adagrad_update"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LinearRegressionOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_LinearRegressionOutput ::
-                        forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args =>
-                          ArgsHMap "_LinearRegressionOutput(ndarray)" args ->
-                            IO [NDArrayHandle]
-_LinearRegressionOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LinearRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LinearRegressionOutput_upd ::
-                            forall args . Fullfilled "_LinearRegressionOutput(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_LinearRegressionOutput(ndarray)" args -> IO ()
-_LinearRegressionOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LinearRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_linear_reg_out(ndarray)" =
-     '[]
-
-_backward_linear_reg_out ::
-                         forall args .
-                           Fullfilled "_backward_linear_reg_out(ndarray)" args =>
-                           ArgsHMap "_backward_linear_reg_out(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_linear_reg_out args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linear_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_linear_reg_out_upd ::
-                             forall args .
-                               Fullfilled "_backward_linear_reg_out(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_linear_reg_out(ndarray)" args -> IO ()
-_backward_linear_reg_out_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linear_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_MAERegressionOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_MAERegressionOutput ::
-                     forall args . Fullfilled "_MAERegressionOutput(ndarray)" args =>
-                       ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO [NDArrayHandle]
-_MAERegressionOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MAERegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_MAERegressionOutput_upd ::
-                         forall args . Fullfilled "_MAERegressionOutput(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_MAERegressionOutput(ndarray)" args -> IO ()
-_MAERegressionOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MAERegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_mae_reg_out(ndarray)" = '[]
-
-_backward_mae_reg_out ::
-                      forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args =>
-                        ArgsHMap "_backward_mae_reg_out(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_mae_reg_out args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mae_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_mae_reg_out_upd ::
-                          forall args . Fullfilled "_backward_mae_reg_out(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_mae_reg_out(ndarray)" args -> IO ()
-_backward_mae_reg_out_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mae_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_LogisticRegressionOutput(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_LogisticRegressionOutput ::
-                          forall args .
-                            Fullfilled "_LogisticRegressionOutput(ndarray)" args =>
-                            ArgsHMap "_LogisticRegressionOutput(ndarray)" args ->
-                              IO [NDArrayHandle]
-_LogisticRegressionOutput args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LogisticRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_LogisticRegressionOutput_upd ::
-                              forall args .
-                                Fullfilled "_LogisticRegressionOutput(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_LogisticRegressionOutput(ndarray)" args -> IO ()
-_LogisticRegressionOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LogisticRegressionOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_logistic_reg_out(ndarray)" =
-     '[]
-
-_backward_logistic_reg_out ::
-                           forall args .
-                             Fullfilled "_backward_logistic_reg_out(ndarray)" args =>
-                             ArgsHMap "_backward_logistic_reg_out(ndarray)" args ->
-                               IO [NDArrayHandle]
-_backward_logistic_reg_out args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_logistic_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_logistic_reg_out_upd ::
-                               forall args .
-                                 Fullfilled "_backward_logistic_reg_out(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_backward_logistic_reg_out(ndarray)" args -> IO ()
-_backward_logistic_reg_out_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_logistic_reg_out"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CustomFunction(ndarray)" = '[]
-
-_CustomFunction ::
-                forall args . Fullfilled "_CustomFunction(ndarray)" args =>
-                  ArgsHMap "_CustomFunction(ndarray)" args -> IO [NDArrayHandle]
-_CustomFunction args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CustomFunction_upd ::
-                    forall args . Fullfilled "_CustomFunction(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_CustomFunction(ndarray)" args -> IO ()
-_CustomFunction_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_CustomFunction(ndarray)" =
-     '[]
-
-_backward_CustomFunction ::
-                         forall args .
-                           Fullfilled "_backward_CustomFunction(ndarray)" args =>
-                           ArgsHMap "_backward_CustomFunction(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_CustomFunction args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_CustomFunction_upd ::
-                             forall args .
-                               Fullfilled "_backward_CustomFunction(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_CustomFunction(ndarray)" args -> IO ()
-_backward_CustomFunction_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CustomFunction"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__Native(ndarray)" = '[]
-
-_backward__Native ::
-                  forall args . Fullfilled "_backward__Native(ndarray)" args =>
-                    ArgsHMap "_backward__Native(ndarray)" args -> IO [NDArrayHandle]
-_backward__Native args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__Native"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__Native_upd ::
-                      forall args . Fullfilled "_backward__Native(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_backward__Native(ndarray)" args -> IO ()
-_backward__Native_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__Native"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__NDArray(ndarray)" = '[]
-
-_backward__NDArray ::
-                   forall args . Fullfilled "_backward__NDArray(ndarray)" args =>
-                     ArgsHMap "_backward__NDArray(ndarray)" args -> IO [NDArrayHandle]
-_backward__NDArray args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__NDArray"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__NDArray_upd ::
-                       forall args . Fullfilled "_backward__NDArray(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward__NDArray(ndarray)" args -> IO ()
-_backward__NDArray_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__NDArray"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiBoxTarget(ndarray)" =
-     '[ '("overlap_threshold", AttrOpt Float),
-        '("ignore_label", AttrOpt Float),
-        '("negative_mining_ratio", AttrOpt Float),
-        '("negative_mining_thresh", AttrOpt Float),
-        '("minimum_negative_samples", AttrOpt Int),
-        '("variances", AttrOpt [Float]),
-        '("anchor", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle),
-        '("cls_pred", AttrOpt NDArrayHandle)]
-
-_contrib_MultiBoxTarget ::
-                        forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args =>
-                          ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args ->
-                            IO [NDArrayHandle]
-_contrib_MultiBoxTarget args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_threshold",) . showValue <$>
-                 (args !? #overlap_threshold :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("negative_mining_ratio",) . showValue <$>
-                 (args !? #negative_mining_ratio :: Maybe Float),
-               ("negative_mining_thresh",) . showValue <$>
-                 (args !? #negative_mining_thresh :: Maybe Float),
-               ("minimum_negative_samples",) . showValue <$>
-                 (args !? #minimum_negative_samples :: Maybe Int),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float])]
-        tensorArgs
-          = catMaybes
-              [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiBoxTarget_upd ::
-                            forall args . Fullfilled "_contrib_MultiBoxTarget(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_contrib_MultiBoxTarget(ndarray)" args -> IO ()
-_contrib_MultiBoxTarget_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_threshold",) . showValue <$>
-                 (args !? #overlap_threshold :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("negative_mining_ratio",) . showValue <$>
-                 (args !? #negative_mining_ratio :: Maybe Float),
-               ("negative_mining_thresh",) . showValue <$>
-                 (args !? #negative_mining_thresh :: Maybe Float),
-               ("minimum_negative_samples",) . showValue <$>
-                 (args !? #minimum_negative_samples :: Maybe Int),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float])]
-        tensorArgs
-          = catMaybes
-              [("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle),
-               ("cls_pred",) <$> (args !? #cls_pred :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxTarget(ndarray)" = '[]
-
-_backward__contrib_MultiBoxTarget ::
-                                  forall args .
-                                    Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)" args =>
-                                    ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args ->
-                                      IO [NDArrayHandle]
-_backward__contrib_MultiBoxTarget args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiBoxTarget_upd ::
-                                      forall args .
-                                        Fullfilled "_backward__contrib_MultiBoxTarget(ndarray)"
-                                          args =>
-                                        [NDArrayHandle] ->
-                                          ArgsHMap "_backward__contrib_MultiBoxTarget(ndarray)" args
-                                            -> IO ()
-_backward__contrib_MultiBoxTarget_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_Proposal(ndarray)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle),
-        '("bbox_pred", AttrOpt NDArrayHandle),
-        '("im_info", AttrOpt NDArrayHandle)]
-
-_contrib_Proposal ::
-                  forall args . Fullfilled "_contrib_Proposal(ndarray)" args =>
-                    ArgsHMap "_contrib_Proposal(ndarray)" args -> IO [NDArrayHandle]
-_contrib_Proposal args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_Proposal_upd ::
-                      forall args . Fullfilled "_contrib_Proposal(ndarray)" args =>
-                        [NDArrayHandle] ->
-                          ArgsHMap "_contrib_Proposal(ndarray)" args -> IO ()
-_contrib_Proposal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__contrib_Proposal(ndarray)"
-     = '[]
-
-_backward__contrib_Proposal ::
-                            forall args .
-                              Fullfilled "_backward__contrib_Proposal(ndarray)" args =>
-                              ArgsHMap "_backward__contrib_Proposal(ndarray)" args ->
-                                IO [NDArrayHandle]
-_backward__contrib_Proposal args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_Proposal_upd ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_Proposal(ndarray)" args =>
-                                  [NDArrayHandle] ->
-                                    ArgsHMap "_backward__contrib_Proposal(ndarray)" args -> IO ()
-_backward__contrib_Proposal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_Proposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_count_sketch(ndarray)" =
-     '[ '("out_dim", AttrReq Int),
-        '("processing_batch_size", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle), '("h", AttrOpt NDArrayHandle),
-        '("s", AttrOpt NDArrayHandle)]
-
-_contrib_count_sketch ::
-                      forall args . Fullfilled "_contrib_count_sketch(ndarray)" args =>
-                        ArgsHMap "_contrib_count_sketch(ndarray)" args ->
-                          IO [NDArrayHandle]
-_contrib_count_sketch args
-  = let scalarArgs
-          = catMaybes
-              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),
-               ("processing_batch_size",) . showValue <$>
-                 (args !? #processing_batch_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("h",) <$> (args !? #h :: Maybe NDArrayHandle),
-               ("s",) <$> (args !? #s :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_count_sketch_upd ::
-                          forall args . Fullfilled "_contrib_count_sketch(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_contrib_count_sketch(ndarray)" args -> IO ()
-_contrib_count_sketch_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),
-               ("processing_batch_size",) . showValue <$>
-                 (args !? #processing_batch_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("h",) <$> (args !? #h :: Maybe NDArrayHandle),
-               ("s",) <$> (args !? #s :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_count_sketch(ndarray)" = '[]
-
-_backward__contrib_count_sketch ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_count_sketch(ndarray)" args =>
-                                  ArgsHMap "_backward__contrib_count_sketch(ndarray)" args ->
-                                    IO [NDArrayHandle]
-_backward__contrib_count_sketch args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_count_sketch_upd ::
-                                    forall args .
-                                      Fullfilled "_backward__contrib_count_sketch(ndarray)" args =>
-                                      [NDArrayHandle] ->
-                                        ArgsHMap "_backward__contrib_count_sketch(ndarray)" args ->
-                                          IO ()
-_backward__contrib_count_sketch_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_count_sketch"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiBoxDetection(ndarray)" =
-     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),
-        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),
-        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),
-        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt NDArrayHandle),
-        '("loc_pred", AttrOpt NDArrayHandle),
-        '("anchor", AttrOpt NDArrayHandle)]
-
-_contrib_MultiBoxDetection ::
-                           forall args .
-                             Fullfilled "_contrib_MultiBoxDetection(ndarray)" args =>
-                             ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args ->
-                               IO [NDArrayHandle]
-_contrib_MultiBoxDetection args
-  = let scalarArgs
-          = catMaybes
-              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("nms_threshold",) . showValue <$>
-                 (args !? #nms_threshold :: Maybe Float),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float]),
-               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle),
-               ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiBoxDetection_upd ::
-                               forall args .
-                                 Fullfilled "_contrib_MultiBoxDetection(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_contrib_MultiBoxDetection(ndarray)" args -> IO ()
-_contrib_MultiBoxDetection_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("nms_threshold",) . showValue <$>
-                 (args !? #nms_threshold :: Maybe Float),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float]),
-               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("loc_pred",) <$> (args !? #loc_pred :: Maybe NDArrayHandle),
-               ("anchor",) <$> (args !? #anchor :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxDetection(ndarray)" = '[]
-
-_backward__contrib_MultiBoxDetection ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiBoxDetection(ndarray)"
-                                         args =>
-                                       ArgsHMap "_backward__contrib_MultiBoxDetection(ndarray)" args
-                                         -> IO [NDArrayHandle]
-_backward__contrib_MultiBoxDetection args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiBoxDetection_upd ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward__contrib_MultiBoxDetection(ndarray)" args =>
-                                           [NDArrayHandle] ->
-                                             ArgsHMap
-                                               "_backward__contrib_MultiBoxDetection(ndarray)"
-                                               args
-                                               -> IO ()
-_backward__contrib_MultiBoxDetection_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_DeformablePSROIPooling(ndarray)"
-     = '[]
-
-_backward__contrib_DeformablePSROIPooling ::
-                                          forall args .
-                                            Fullfilled
-                                              "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                              args =>
-                                            ArgsHMap
-                                              "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                              args
-                                              -> IO [NDArrayHandle]
-_backward__contrib_DeformablePSROIPooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_DeformablePSROIPooling_upd ::
-                                              forall args .
-                                                Fullfilled
-                                                  "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                                  args =>
-                                                [NDArrayHandle] ->
-                                                  ArgsHMap
-                                                    "_backward__contrib_DeformablePSROIPooling(ndarray)"
-                                                    args
-                                                    -> IO ()
-_backward__contrib_DeformablePSROIPooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_fft(ndarray)" =
-     '[ '("compute_size", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_fft ::
-             forall args . Fullfilled "_contrib_fft(ndarray)" args =>
-               ArgsHMap "_contrib_fft(ndarray)" args -> IO [NDArrayHandle]
-_contrib_fft args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_fft_upd ::
-                 forall args . Fullfilled "_contrib_fft(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_contrib_fft(ndarray)" args -> IO ()
-_contrib_fft_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__contrib_fft(ndarray)" = '[]
-
-_backward__contrib_fft ::
-                       forall args . Fullfilled "_backward__contrib_fft(ndarray)" args =>
-                         ArgsHMap "_backward__contrib_fft(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward__contrib_fft args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_fft_upd ::
-                           forall args . Fullfilled "_backward__contrib_fft(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward__contrib_fft(ndarray)" args -> IO ()
-_backward__contrib_fft_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_fft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiBoxPrior(ndarray)" =
-     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),
-        '("offsets", AttrOpt [Float]), '("data", AttrOpt NDArrayHandle)]
-
-_contrib_MultiBoxPrior ::
-                       forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args =>
-                         ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args ->
-                           IO [NDArrayHandle]
-_contrib_MultiBoxPrior args
-  = let scalarArgs
-          = catMaybes
-              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),
-               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiBoxPrior_upd ::
-                           forall args . Fullfilled "_contrib_MultiBoxPrior(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_contrib_MultiBoxPrior(ndarray)" args -> IO ()
-_contrib_MultiBoxPrior_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),
-               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxPrior(ndarray)" = '[]
-
-_backward__contrib_MultiBoxPrior ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)" args =>
-                                   ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args ->
-                                     IO [NDArrayHandle]
-_backward__contrib_MultiBoxPrior args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiBoxPrior_upd ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiBoxPrior(ndarray)"
-                                         args =>
-                                       [NDArrayHandle] ->
-                                         ArgsHMap "_backward__contrib_MultiBoxPrior(ndarray)" args
-                                           -> IO ()
-_backward__contrib_MultiBoxPrior_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_MultiProposal(ndarray)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt NDArrayHandle),
-        '("bbox_pred", AttrOpt NDArrayHandle),
-        '("im_info", AttrOpt NDArrayHandle)]
-
-_contrib_MultiProposal ::
-                       forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args =>
-                         ArgsHMap "_contrib_MultiProposal(ndarray)" args ->
-                           IO [NDArrayHandle]
-_contrib_MultiProposal args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_MultiProposal_upd ::
-                           forall args . Fullfilled "_contrib_MultiProposal(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_contrib_MultiProposal(ndarray)" args -> IO ()
-_contrib_MultiProposal_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe NDArrayHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe NDArrayHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_MultiProposal(ndarray)" = '[]
-
-_backward__contrib_MultiProposal ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiProposal(ndarray)" args =>
-                                   ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args ->
-                                     IO [NDArrayHandle]
-_backward__contrib_MultiProposal args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_MultiProposal_upd ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiProposal(ndarray)"
-                                         args =>
-                                       [NDArrayHandle] ->
-                                         ArgsHMap "_backward__contrib_MultiProposal(ndarray)" args
-                                           -> IO ()
-_backward__contrib_MultiProposal_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_PSROIPooling(ndarray)" = '[]
-
-_backward__contrib_PSROIPooling ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args =>
-                                  ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args ->
-                                    IO [NDArrayHandle]
-_backward__contrib_PSROIPooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_PSROIPooling_upd ::
-                                    forall args .
-                                      Fullfilled "_backward__contrib_PSROIPooling(ndarray)" args =>
-                                      [NDArrayHandle] ->
-                                        ArgsHMap "_backward__contrib_PSROIPooling(ndarray)" args ->
-                                          IO ()
-_backward__contrib_PSROIPooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_contrib_DeformableConvolution(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("num_deformable_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("offset", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_contrib_DeformableConvolution ::
-                               forall args .
-                                 Fullfilled "_contrib_DeformableConvolution(ndarray)" args =>
-                                 ArgsHMap "_contrib_DeformableConvolution(ndarray)" args ->
-                                   IO [NDArrayHandle]
-_contrib_DeformableConvolution args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("num_deformable_group",) . showValue <$>
-                 (args !? #num_deformable_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_DeformableConvolution_upd ::
-                                   forall args .
-                                     Fullfilled "_contrib_DeformableConvolution(ndarray)" args =>
-                                     [NDArrayHandle] ->
-                                       ArgsHMap "_contrib_DeformableConvolution(ndarray)" args ->
-                                         IO ()
-_contrib_DeformableConvolution_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("num_deformable_group",) . showValue <$>
-                 (args !? #num_deformable_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("offset",) <$> (args !? #offset :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_DeformableConvolution(ndarray)" =
-     '[]
-
-_backward__contrib_DeformableConvolution ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward__contrib_DeformableConvolution(ndarray)"
-                                             args =>
-                                           ArgsHMap
-                                             "_backward__contrib_DeformableConvolution(ndarray)"
-                                             args
-                                             -> IO [NDArrayHandle]
-_backward__contrib_DeformableConvolution args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_DeformableConvolution_upd ::
-                                             forall args .
-                                               Fullfilled
-                                                 "_backward__contrib_DeformableConvolution(ndarray)"
-                                                 args =>
-                                               [NDArrayHandle] ->
-                                                 ArgsHMap
-                                                   "_backward__contrib_DeformableConvolution(ndarray)"
-                                                   args
-                                                   -> IO ()
-_backward__contrib_DeformableConvolution_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_contrib_ifft(ndarray)" =
-     '[ '("compute_size", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle)]
-
-_contrib_ifft ::
-              forall args . Fullfilled "_contrib_ifft(ndarray)" args =>
-                ArgsHMap "_contrib_ifft(ndarray)" args -> IO [NDArrayHandle]
-_contrib_ifft args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_contrib_ifft_upd ::
-                  forall args . Fullfilled "_contrib_ifft(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_contrib_ifft(ndarray)" args -> IO ()
-_contrib_ifft_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__contrib_ifft(ndarray)" =
-     '[]
-
-_backward__contrib_ifft ::
-                        forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args =>
-                          ArgsHMap "_backward__contrib_ifft(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward__contrib_ifft args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_ifft_upd ::
-                            forall args . Fullfilled "_backward__contrib_ifft(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward__contrib_ifft(ndarray)" args -> IO ()
-_backward__contrib_ifft_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_ifft"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward__contrib_SyncBatchNorm(ndarray)" = '[]
-
-_backward__contrib_SyncBatchNorm ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)" args =>
-                                   ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args ->
-                                     IO [NDArrayHandle]
-_backward__contrib_SyncBatchNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__contrib_SyncBatchNorm_upd ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_SyncBatchNorm(ndarray)"
-                                         args =>
-                                       [NDArrayHandle] ->
-                                         ArgsHMap "_backward__contrib_SyncBatchNorm(ndarray)" args
-                                           -> IO ()
-_backward__contrib_SyncBatchNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_InstanceNorm(ndarray)" =
-     '[ '("eps", AttrOpt Float), '("data", AttrOpt NDArrayHandle),
-        '("gamma", AttrOpt NDArrayHandle),
-        '("beta", AttrOpt NDArrayHandle)]
-
-_InstanceNorm ::
-              forall args . Fullfilled "_InstanceNorm(ndarray)" args =>
-                ArgsHMap "_InstanceNorm(ndarray)" args -> IO [NDArrayHandle]
-_InstanceNorm args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_InstanceNorm_upd ::
-                  forall args . Fullfilled "_InstanceNorm(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_InstanceNorm(ndarray)" args -> IO ()
-_InstanceNorm_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe NDArrayHandle),
-               ("beta",) <$> (args !? #beta :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_InstanceNorm(ndarray)" = '[]
-
-_backward_InstanceNorm ::
-                       forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args =>
-                         ArgsHMap "_backward_InstanceNorm(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_InstanceNorm args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_InstanceNorm_upd ::
-                           forall args . Fullfilled "_backward_InstanceNorm(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_InstanceNorm(ndarray)" args -> IO ()
-_backward_InstanceNorm_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_InstanceNorm"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SVMOutput(ndarray)" =
-     '[ '("margin", AttrOpt Float),
-        '("regularization_coefficient", AttrOpt Float),
-        '("use_linear", AttrOpt Bool), '("data", AttrOpt NDArrayHandle),
-        '("label", AttrOpt NDArrayHandle)]
-
-_SVMOutput ::
-           forall args . Fullfilled "_SVMOutput(ndarray)" args =>
-             ArgsHMap "_SVMOutput(ndarray)" args -> IO [NDArrayHandle]
-_SVMOutput args
-  = let scalarArgs
-          = catMaybes
-              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),
-               ("regularization_coefficient",) . showValue <$>
-                 (args !? #regularization_coefficient :: Maybe Float),
-               ("use_linear",) . showValue <$>
-                 (args !? #use_linear :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SVMOutput_upd ::
-               forall args . Fullfilled "_SVMOutput(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_SVMOutput(ndarray)" args -> IO ()
-_SVMOutput_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),
-               ("regularization_coefficient",) . showValue <$>
-                 (args !? #regularization_coefficient :: Maybe Float),
-               ("use_linear",) . showValue <$>
-                 (args !? #use_linear :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("label",) <$> (args !? #label :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SVMOutput(ndarray)" = '[]
-
-_backward_SVMOutput ::
-                    forall args . Fullfilled "_backward_SVMOutput(ndarray)" args =>
-                      ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO [NDArrayHandle]
-_backward_SVMOutput args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SVMOutput_upd ::
-                        forall args . Fullfilled "_backward_SVMOutput(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_SVMOutput(ndarray)" args -> IO ()
-_backward_SVMOutput_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SVMOutput"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_GridGenerator(ndarray)" =
-     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),
-        '("target_shape", AttrOpt [Int]), '("data", AttrOpt NDArrayHandle)]
-
-_GridGenerator ::
-               forall args . Fullfilled "_GridGenerator(ndarray)" args =>
-                 ArgsHMap "_GridGenerator(ndarray)" args -> IO [NDArrayHandle]
-_GridGenerator args
-  = let scalarArgs
-          = catMaybes
-              [("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_GridGenerator_upd ::
-                   forall args . Fullfilled "_GridGenerator(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_GridGenerator(ndarray)" args -> IO ()
-_GridGenerator_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_GridGenerator(ndarray)" =
-     '[]
-
-_backward_GridGenerator ::
-                        forall args . Fullfilled "_backward_GridGenerator(ndarray)" args =>
-                          ArgsHMap "_backward_GridGenerator(ndarray)" args ->
-                            IO [NDArrayHandle]
-_backward_GridGenerator args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_GridGenerator_upd ::
-                            forall args . Fullfilled "_backward_GridGenerator(ndarray)" args =>
-                              [NDArrayHandle] ->
-                                ArgsHMap "_backward_GridGenerator(ndarray)" args -> IO ()
-_backward_GridGenerator_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_GridGenerator"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Convolution_v1(ndarray)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt NDArrayHandle),
-        '("weight", AttrOpt NDArrayHandle),
-        '("bias", AttrOpt NDArrayHandle)]
-
-_Convolution_v1 ::
-                forall args . Fullfilled "_Convolution_v1(ndarray)" args =>
-                  ArgsHMap "_Convolution_v1(ndarray)" args -> IO [NDArrayHandle]
-_Convolution_v1 args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Convolution_v1_upd ::
-                    forall args . Fullfilled "_Convolution_v1(ndarray)" args =>
-                      [NDArrayHandle] ->
-                        ArgsHMap "_Convolution_v1(ndarray)" args -> IO ()
-_Convolution_v1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("weight",) <$> (args !? #weight :: Maybe NDArrayHandle),
-               ("bias",) <$> (args !? #bias :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Convolution_v1(ndarray)" =
-     '[]
-
-_backward_Convolution_v1 ::
-                         forall args .
-                           Fullfilled "_backward_Convolution_v1(ndarray)" args =>
-                           ArgsHMap "_backward_Convolution_v1(ndarray)" args ->
-                             IO [NDArrayHandle]
-_backward_Convolution_v1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Convolution_v1_upd ::
-                             forall args .
-                               Fullfilled "_backward_Convolution_v1(ndarray)" args =>
-                               [NDArrayHandle] ->
-                                 ArgsHMap "_backward_Convolution_v1(ndarray)" args -> IO ()
-_backward_Convolution_v1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SequenceReverse(ndarray)" =
-     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle),
-        '("sequence_length", AttrOpt NDArrayHandle)]
-
-_SequenceReverse ::
-                 forall args . Fullfilled "_SequenceReverse(ndarray)" args =>
-                   ArgsHMap "_SequenceReverse(ndarray)" args -> IO [NDArrayHandle]
-_SequenceReverse args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SequenceReverse_upd ::
-                     forall args . Fullfilled "_SequenceReverse(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_SequenceReverse(ndarray)" args -> IO ()
-_SequenceReverse_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SequenceReverse(ndarray)" =
-     '[]
-
-_backward_SequenceReverse ::
-                          forall args .
-                            Fullfilled "_backward_SequenceReverse(ndarray)" args =>
-                            ArgsHMap "_backward_SequenceReverse(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_SequenceReverse args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SequenceReverse_upd ::
-                              forall args .
-                                Fullfilled "_backward_SequenceReverse(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_SequenceReverse(ndarray)" args -> IO ()
-_backward_SequenceReverse_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceReverse"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_BilinearSampler(ndarray)" =
-     '[ '("cudnn_off", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt NDArrayHandle), '("grid", AttrOpt NDArrayHandle)]
-
-_BilinearSampler ::
-                 forall args . Fullfilled "_BilinearSampler(ndarray)" args =>
-                   ArgsHMap "_BilinearSampler(ndarray)" args -> IO [NDArrayHandle]
-_BilinearSampler args
-  = let scalarArgs
-          = catMaybes
-              [("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_BilinearSampler_upd ::
-                     forall args . Fullfilled "_BilinearSampler(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_BilinearSampler(ndarray)" args -> IO ()
-_BilinearSampler_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("grid",) <$> (args !? #grid :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_BilinearSampler(ndarray)" =
-     '[]
-
-_backward_BilinearSampler ::
-                          forall args .
-                            Fullfilled "_backward_BilinearSampler(ndarray)" args =>
-                            ArgsHMap "_backward_BilinearSampler(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_BilinearSampler args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_BilinearSampler_upd ::
-                              forall args .
-                                Fullfilled "_backward_BilinearSampler(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_BilinearSampler(ndarray)" args -> IO ()
-_backward_BilinearSampler_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BilinearSampler"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_LeakyReLU(ndarray)" = '[]
-
-_backward_LeakyReLU ::
-                    forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args =>
-                      ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO [NDArrayHandle]
-_backward_LeakyReLU args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_LeakyReLU_upd ::
-                        forall args . Fullfilled "_backward_LeakyReLU(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_backward_LeakyReLU(ndarray)" args -> IO ()
-_backward_LeakyReLU_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LeakyReLU"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Crop(ndarray)" =
-     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),
-        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),
-        '("data", AttrOpt [NDArrayHandle])]
-
-_Crop ::
-      forall args . Fullfilled "_Crop(ndarray)" args =>
-        ArgsHMap "_Crop(ndarray)" args -> IO [NDArrayHandle]
-_Crop args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),
-               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),
-               ("center_crop",) . showValue <$>
-                 (args !? #center_crop :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Crop"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        Nothing
-         return listndarr
-
-_Crop_upd ::
-          forall args . Fullfilled "_Crop(ndarray)" args =>
-            [NDArrayHandle] -> ArgsHMap "_Crop(ndarray)" args -> IO ()
-_Crop_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),
-               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),
-               ("center_crop",) . showValue <$>
-                 (args !? #center_crop :: Maybe Bool)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [NDArrayHandle])
-      in
-      do op <- nnGetOpHandle "Crop"
-         let scalarArgs'
-               = if hasKey args #num_args then scalarArgs else
-                   (,) "num_args" (showValue (length array)) : scalarArgs
-         listndarr <- mxImperativeInvoke (fromOpHandle op) array scalarArgs'
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Crop(ndarray)" = '[]
-
-_backward_Crop ::
-               forall args . Fullfilled "_backward_Crop(ndarray)" args =>
-                 ArgsHMap "_backward_Crop(ndarray)" args -> IO [NDArrayHandle]
-_backward_Crop args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Crop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Crop_upd ::
-                   forall args . Fullfilled "_backward_Crop(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_backward_Crop(ndarray)" args -> IO ()
-_backward_Crop_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Crop"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_ROIPooling(ndarray)" =
-     '[ '("pooled_size", AttrReq [Int]),
-        '("spatial_scale", AttrReq Float),
-        '("data", AttrOpt NDArrayHandle), '("rois", AttrOpt NDArrayHandle)]
-
-_ROIPooling ::
-            forall args . Fullfilled "_ROIPooling(ndarray)" args =>
-              ArgsHMap "_ROIPooling(ndarray)" args -> IO [NDArrayHandle]
-_ROIPooling args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_ROIPooling_upd ::
-                forall args . Fullfilled "_ROIPooling(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_ROIPooling(ndarray)" args -> IO ()
-_ROIPooling_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("rois",) <$> (args !? #rois :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_ROIPooling(ndarray)" = '[]
-
-_backward_ROIPooling ::
-                     forall args . Fullfilled "_backward_ROIPooling(ndarray)" args =>
-                       ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO [NDArrayHandle]
-_backward_ROIPooling args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_ROIPooling_upd ::
-                         forall args . Fullfilled "_backward_ROIPooling(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_ROIPooling(ndarray)" args -> IO ()
-_backward_ROIPooling_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIPooling"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SequenceLast(ndarray)" =
-     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle),
-        '("sequence_length", AttrOpt NDArrayHandle)]
-
-_SequenceLast ::
-              forall args . Fullfilled "_SequenceLast(ndarray)" args =>
-                ArgsHMap "_SequenceLast(ndarray)" args -> IO [NDArrayHandle]
-_SequenceLast args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SequenceLast_upd ::
-                  forall args . Fullfilled "_SequenceLast(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_SequenceLast(ndarray)" args -> IO ()
-_SequenceLast_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SequenceLast(ndarray)" = '[]
-
-_backward_SequenceLast ::
-                       forall args . Fullfilled "_backward_SequenceLast(ndarray)" args =>
-                         ArgsHMap "_backward_SequenceLast(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_SequenceLast args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SequenceLast_upd ::
-                           forall args . Fullfilled "_backward_SequenceLast(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_SequenceLast(ndarray)" args -> IO ()
-_backward_SequenceLast_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceLast"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_CrossDeviceCopy(ndarray)" = '[]
-
-_CrossDeviceCopy ::
-                 forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args =>
-                   ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO [NDArrayHandle]
-_CrossDeviceCopy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_CrossDeviceCopy_upd ::
-                     forall args . Fullfilled "_CrossDeviceCopy(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_CrossDeviceCopy(ndarray)" args -> IO ()
-_CrossDeviceCopy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward__CrossDeviceCopy(ndarray)" =
-     '[]
-
-_backward__CrossDeviceCopy ::
-                           forall args .
-                             Fullfilled "_backward__CrossDeviceCopy(ndarray)" args =>
-                             ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args ->
-                               IO [NDArrayHandle]
-_backward__CrossDeviceCopy args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward__CrossDeviceCopy_upd ::
-                               forall args .
-                                 Fullfilled "_backward__CrossDeviceCopy(ndarray)" args =>
-                                 [NDArrayHandle] ->
-                                   ArgsHMap "_backward__CrossDeviceCopy(ndarray)" args -> IO ()
-_backward__CrossDeviceCopy_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SpatialTransformer(ndarray)" =
-     '[ '("target_shape", AttrOpt [Int]),
-        '("transform_type", AttrReq (EnumType '["affine"])),
-        '("sampler_type", AttrReq (EnumType '["bilinear"])),
-        '("cudnn_off", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt NDArrayHandle), '("loc", AttrOpt NDArrayHandle)]
-
-_SpatialTransformer ::
-                    forall args . Fullfilled "_SpatialTransformer(ndarray)" args =>
-                      ArgsHMap "_SpatialTransformer(ndarray)" args -> IO [NDArrayHandle]
-_SpatialTransformer args
-  = let scalarArgs
-          = catMaybes
-              [("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine"])),
-               ("sampler_type",) . showValue <$>
-                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"])),
-               ("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SpatialTransformer_upd ::
-                        forall args . Fullfilled "_SpatialTransformer(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "_SpatialTransformer(ndarray)" args -> IO ()
-_SpatialTransformer_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine"])),
-               ("sampler_type",) . showValue <$>
-                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"])),
-               ("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("loc",) <$> (args !? #loc :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SpatialTransformer(ndarray)"
-     = '[]
-
-_backward_SpatialTransformer ::
-                             forall args .
-                               Fullfilled "_backward_SpatialTransformer(ndarray)" args =>
-                               ArgsHMap "_backward_SpatialTransformer(ndarray)" args ->
-                                 IO [NDArrayHandle]
-_backward_SpatialTransformer args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SpatialTransformer_upd ::
-                                 forall args .
-                                   Fullfilled "_backward_SpatialTransformer(ndarray)" args =>
-                                   [NDArrayHandle] ->
-                                     ArgsHMap "_backward_SpatialTransformer(ndarray)" args -> IO ()
-_backward_SpatialTransformer_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SpatialTransformer"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SwapAxis(ndarray)" = '[]
-
-_backward_SwapAxis ::
-                   forall args . Fullfilled "_backward_SwapAxis(ndarray)" args =>
-                     ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO [NDArrayHandle]
-_backward_SwapAxis args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SwapAxis_upd ::
-                       forall args . Fullfilled "_backward_SwapAxis(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_SwapAxis(ndarray)" args -> IO ()
-_backward_SwapAxis_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SwapAxis"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_L2Normalization(ndarray)" =
-     '[ '("eps", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_L2Normalization ::
-                 forall args . Fullfilled "_L2Normalization(ndarray)" args =>
-                   ArgsHMap "_L2Normalization(ndarray)" args -> IO [NDArrayHandle]
-_L2Normalization args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["channel", "instance", "spatial"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_L2Normalization_upd ::
-                     forall args . Fullfilled "_L2Normalization(ndarray)" args =>
-                       [NDArrayHandle] ->
-                         ArgsHMap "_L2Normalization(ndarray)" args -> IO ()
-_L2Normalization_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["channel", "instance", "spatial"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_L2Normalization(ndarray)" =
-     '[]
-
-_backward_L2Normalization ::
-                          forall args .
-                            Fullfilled "_backward_L2Normalization(ndarray)" args =>
-                            ArgsHMap "_backward_L2Normalization(ndarray)" args ->
-                              IO [NDArrayHandle]
-_backward_L2Normalization args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_L2Normalization_upd ::
-                              forall args .
-                                Fullfilled "_backward_L2Normalization(ndarray)" args =>
-                                [NDArrayHandle] ->
-                                  ArgsHMap "_backward_L2Normalization(ndarray)" args -> IO ()
-_backward_L2Normalization_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_L2Normalization"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Correlation(ndarray)" =
-     '[ '("kernel_size", AttrOpt Int),
-        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),
-        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),
-        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt NDArrayHandle),
-        '("data2", AttrOpt NDArrayHandle)]
-
-_Correlation ::
-             forall args . Fullfilled "_Correlation(ndarray)" args =>
-               ArgsHMap "_Correlation(ndarray)" args -> IO [NDArrayHandle]
-_Correlation args
-  = let scalarArgs
-          = catMaybes
-              [("kernel_size",) . showValue <$>
-                 (args !? #kernel_size :: Maybe Int),
-               ("max_displacement",) . showValue <$>
-                 (args !? #max_displacement :: Maybe Int),
-               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),
-               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),
-               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),
-               ("is_multiply",) . showValue <$>
-                 (args !? #is_multiply :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle),
-               ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Correlation_upd ::
-                 forall args . Fullfilled "_Correlation(ndarray)" args =>
-                   [NDArrayHandle] -> ArgsHMap "_Correlation(ndarray)" args -> IO ()
-_Correlation_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel_size",) . showValue <$>
-                 (args !? #kernel_size :: Maybe Int),
-               ("max_displacement",) . showValue <$>
-                 (args !? #max_displacement :: Maybe Int),
-               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),
-               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),
-               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),
-               ("is_multiply",) . showValue <$>
-                 (args !? #is_multiply :: Maybe Bool)]
-        tensorArgs
-          = catMaybes
-              [("data1",) <$> (args !? #data1 :: Maybe NDArrayHandle),
-               ("data2",) <$> (args !? #data2 :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Correlation(ndarray)" = '[]
-
-_backward_Correlation ::
-                      forall args . Fullfilled "_backward_Correlation(ndarray)" args =>
-                        ArgsHMap "_backward_Correlation(ndarray)" args ->
-                          IO [NDArrayHandle]
-_backward_Correlation args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Correlation_upd ::
-                          forall args . Fullfilled "_backward_Correlation(ndarray)" args =>
-                            [NDArrayHandle] ->
-                              ArgsHMap "_backward_Correlation(ndarray)" args -> IO ()
-_backward_Correlation_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Correlation"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance
-     ParameterList "_backward_IdentityAttachKLSparseReg(ndarray)" = '[]
-
-_backward_IdentityAttachKLSparseReg ::
-                                    forall args .
-                                      Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)"
-                                        args =>
-                                      ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)" args
-                                        -> IO [NDArrayHandle]
-_backward_IdentityAttachKLSparseReg args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_IdentityAttachKLSparseReg_upd ::
-                                        forall args .
-                                          Fullfilled "_backward_IdentityAttachKLSparseReg(ndarray)"
-                                            args =>
-                                          [NDArrayHandle] ->
-                                            ArgsHMap "_backward_IdentityAttachKLSparseReg(ndarray)"
-                                              args
-                                              -> IO ()
-_backward_IdentityAttachKLSparseReg_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_MakeLoss(ndarray)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("data", AttrOpt NDArrayHandle)]
-
-_MakeLoss ::
-          forall args . Fullfilled "_MakeLoss(ndarray)" args =>
-            ArgsHMap "_MakeLoss(ndarray)" args -> IO [NDArrayHandle]
-_MakeLoss args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_MakeLoss_upd ::
-              forall args . Fullfilled "_MakeLoss(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_MakeLoss(ndarray)" args -> IO ()
-_MakeLoss_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"]))]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_MakeLoss(ndarray)" = '[]
-
-_backward_MakeLoss ::
-                   forall args . Fullfilled "_backward_MakeLoss(ndarray)" args =>
-                     ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO [NDArrayHandle]
-_backward_MakeLoss args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_MakeLoss_upd ::
-                       forall args . Fullfilled "_backward_MakeLoss(ndarray)" args =>
-                         [NDArrayHandle] ->
-                           ArgsHMap "_backward_MakeLoss(ndarray)" args -> IO ()
-_backward_MakeLoss_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MakeLoss"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SliceChannel(ndarray)" = '[]
-
-_backward_SliceChannel ::
-                       forall args . Fullfilled "_backward_SliceChannel(ndarray)" args =>
-                         ArgsHMap "_backward_SliceChannel(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_SliceChannel args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SliceChannel_upd ::
-                           forall args . Fullfilled "_backward_SliceChannel(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_SliceChannel(ndarray)" args -> IO ()
-_backward_SliceChannel_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SliceChannel"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_Pooling_v1(ndarray)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])),
-        '("global_pool", AttrOpt Bool),
-        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("data", AttrOpt NDArrayHandle)]
-
-_Pooling_v1 ::
-            forall args . Fullfilled "_Pooling_v1(ndarray)" args =>
-              ArgsHMap "_Pooling_v1(ndarray)" args -> IO [NDArrayHandle]
-_Pooling_v1 args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_Pooling_v1_upd ::
-                forall args . Fullfilled "_Pooling_v1(ndarray)" args =>
-                  [NDArrayHandle] -> ArgsHMap "_Pooling_v1(ndarray)" args -> IO ()
-_Pooling_v1_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Pooling_v1(ndarray)" = '[]
-
-_backward_Pooling_v1 ::
-                     forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args =>
-                       ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO [NDArrayHandle]
-_backward_Pooling_v1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Pooling_v1_upd ::
-                         forall args . Fullfilled "_backward_Pooling_v1(ndarray)" args =>
-                           [NDArrayHandle] ->
-                             ArgsHMap "_backward_Pooling_v1(ndarray)" args -> IO ()
-_backward_Pooling_v1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_Pad(ndarray)" = '[]
-
-_backward_Pad ::
-              forall args . Fullfilled "_backward_Pad(ndarray)" args =>
-                ArgsHMap "_backward_Pad(ndarray)" args -> IO [NDArrayHandle]
-_backward_Pad args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_Pad_upd ::
-                  forall args . Fullfilled "_backward_Pad(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_backward_Pad(ndarray)" args -> IO ()
-_backward_Pad_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pad"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_BatchNorm_v1(ndarray)" = '[]
-
-_backward_BatchNorm_v1 ::
-                       forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args =>
-                         ArgsHMap "_backward_BatchNorm_v1(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_BatchNorm_v1 args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_BatchNorm_v1_upd ::
-                           forall args . Fullfilled "_backward_BatchNorm_v1(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_BatchNorm_v1(ndarray)" args -> IO ()
-_backward_BatchNorm_v1_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm_v1"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_SequenceMask(ndarray)" =
-     '[ '("use_sequence_length", AttrOpt Bool),
-        '("value", AttrOpt Float), '("axis", AttrOpt Int),
-        '("data", AttrOpt NDArrayHandle),
-        '("sequence_length", AttrOpt NDArrayHandle)]
-
-_SequenceMask ::
-              forall args . Fullfilled "_SequenceMask(ndarray)" args =>
-                ArgsHMap "_SequenceMask(ndarray)" args -> IO [NDArrayHandle]
-_SequenceMask args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("value",) . showValue <$> (args !? #value :: Maybe Float),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_SequenceMask_upd ::
-                  forall args . Fullfilled "_SequenceMask(ndarray)" args =>
-                    [NDArrayHandle] -> ArgsHMap "_SequenceMask(ndarray)" args -> IO ()
-_SequenceMask_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("value",) . showValue <$> (args !? #value :: Maybe Float),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe NDArrayHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_backward_SequenceMask(ndarray)" = '[]
-
-_backward_SequenceMask ::
-                       forall args . Fullfilled "_backward_SequenceMask(ndarray)" args =>
-                         ArgsHMap "_backward_SequenceMask(ndarray)" args ->
-                           IO [NDArrayHandle]
-_backward_SequenceMask args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_backward_SequenceMask_upd ::
-                           forall args . Fullfilled "_backward_SequenceMask(ndarray)" args =>
-                             [NDArrayHandle] ->
-                               ArgsHMap "_backward_SequenceMask(ndarray)" args -> IO ()
-_backward_SequenceMask_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceMask"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_set_value(ndarray)" =
-     '[ '("src", AttrOpt Float)]
-
-_set_value ::
-           forall args . Fullfilled "_set_value(ndarray)" args =>
-             ArgsHMap "_set_value(ndarray)" args -> IO [NDArrayHandle]
-_set_value args
-  = let scalarArgs
-          = catMaybes
-              [("src",) . showValue <$> (args !? #src :: Maybe Float)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_set_value"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_set_value_upd ::
-               forall args . Fullfilled "_set_value(ndarray)" args =>
-                 [NDArrayHandle] -> ArgsHMap "_set_value(ndarray)" args -> IO ()
-_set_value_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("src",) . showValue <$> (args !? #src :: Maybe Float)]
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_set_value"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_onehot_encode(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("rhs", AttrOpt NDArrayHandle)]
-
-_onehot_encode ::
-               forall args . Fullfilled "_onehot_encode(ndarray)" args =>
-                 ArgsHMap "_onehot_encode(ndarray)" args -> IO [NDArrayHandle]
-_onehot_encode args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_onehot_encode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_onehot_encode_upd ::
-                   forall args . Fullfilled "_onehot_encode(ndarray)" args =>
-                     [NDArrayHandle] -> ArgsHMap "_onehot_encode(ndarray)" args -> IO ()
-_onehot_encode_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_onehot_encode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "fill_element_0index(ndarray)" =
-     '[ '("lhs", AttrOpt NDArrayHandle),
-        '("mhs", AttrOpt NDArrayHandle), '("rhs", AttrOpt NDArrayHandle)]
-
-fill_element_0index ::
-                    forall args . Fullfilled "fill_element_0index(ndarray)" args =>
-                      ArgsHMap "fill_element_0index(ndarray)" args -> IO [NDArrayHandle]
-fill_element_0index args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fill_element_0index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-fill_element_0index_upd ::
-                        forall args . Fullfilled "fill_element_0index(ndarray)" args =>
-                          [NDArrayHandle] ->
-                            ArgsHMap "fill_element_0index(ndarray)" args -> IO ()
-fill_element_0index_upd outputs args
-  = let scalarArgs = catMaybes []
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe NDArrayHandle),
-               ("mhs",) <$> (args !? #mhs :: Maybe NDArrayHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fill_element_0index"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
-
-type instance ParameterList "_imdecode(ndarray)" =
-     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),
-        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),
-        '("c", AttrOpt Int), '("size", AttrOpt Int),
-        '("mean", AttrOpt NDArrayHandle)]
-
-_imdecode ::
-          forall args . Fullfilled "_imdecode(ndarray)" args =>
-            ArgsHMap "_imdecode(ndarray)" args -> IO [NDArrayHandle]
-_imdecode args
-  = let scalarArgs
-          = catMaybes
-              [("index",) . showValue <$> (args !? #index :: Maybe Int),
-               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),
-               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),
-               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),
-               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),
-               ("c",) . showValue <$> (args !? #c :: Maybe Int),
-               ("size",) . showValue <$> (args !? #size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_imdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        Nothing
-         return listndarr
-
-_imdecode_upd ::
-              forall args . Fullfilled "_imdecode(ndarray)" args =>
-                [NDArrayHandle] -> ArgsHMap "_imdecode(ndarray)" args -> IO ()
-_imdecode_upd outputs args
-  = let scalarArgs
-          = catMaybes
-              [("index",) . showValue <$> (args !? #index :: Maybe Int),
-               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),
-               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),
-               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),
-               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),
-               ("c",) . showValue <$> (args !? #c :: Maybe Int),
-               ("size",) . showValue <$> (args !? #size :: Maybe Int)]
-        tensorArgs
-          = catMaybes [("mean",) <$> (args !? #mean :: Maybe NDArrayHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_imdecode"
-         listndarr <- mxImperativeInvoke (fromOpHandle op) tensorvals
-                        scalarArgs
-                        (Just outputs)
-         return ()
diff --git a/ops/1.5/MXNet/Base/Operators/Symbol.hs b/ops/1.5/MXNet/Base/Operators/Symbol.hs
deleted file mode 100644
--- a/ops/1.5/MXNet/Base/Operators/Symbol.hs
+++ /dev/null
@@ -1,13179 +0,0 @@
-module MXNet.Base.Operators.Symbol where
-import MXNet.Base.Raw
-import MXNet.Base.Spec.Operator
-import MXNet.Base.Spec.HMap
-import Data.Maybe (catMaybes, fromMaybe)
-
-type instance ParameterList "_CuDNNBatchNorm(symbol)" =
-     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),
-        '("moving_mean", AttrOpt SymbolHandle),
-        '("moving_var", AttrOpt SymbolHandle)]
-
-_CuDNNBatchNorm ::
-                forall args . Fullfilled "_CuDNNBatchNorm(symbol)" args =>
-                  String ->
-                    ArgsHMap "_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle
-_CuDNNBatchNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CuDNNBatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_CuDNNBatchNorm(symbol)" =
-     '[]
-
-_backward_CuDNNBatchNorm ::
-                         forall args . Fullfilled "_backward_CuDNNBatchNorm(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_CuDNNBatchNorm(symbol)" args -> IO SymbolHandle
-_backward_CuDNNBatchNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CuDNNBatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_multinomial(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_sample_multinomial ::
-                    forall args . Fullfilled "_sample_multinomial(symbol)" args =>
-                      String ->
-                        ArgsHMap "_sample_multinomial(symbol)" args -> IO SymbolHandle
-_sample_multinomial name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_multinomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sample_multinomial(symbol)"
-     = '[]
-
-_backward_sample_multinomial ::
-                             forall args .
-                               Fullfilled "_backward_sample_multinomial(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_backward_sample_multinomial(symbol)" args ->
-                                   IO SymbolHandle
-_backward_sample_multinomial name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sample_multinomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_uniform(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("low", AttrOpt SymbolHandle), '("high", AttrOpt SymbolHandle)]
-
-_sample_uniform ::
-                forall args . Fullfilled "_sample_uniform(symbol)" args =>
-                  String ->
-                    ArgsHMap "_sample_uniform(symbol)" args -> IO SymbolHandle
-_sample_uniform name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("low",) <$> (args !? #low :: Maybe SymbolHandle),
-               ("high",) <$> (args !? #high :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_uniform"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_normal(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt SymbolHandle), '("sigma", AttrOpt SymbolHandle)]
-
-_sample_normal ::
-               forall args . Fullfilled "_sample_normal(symbol)" args =>
-                 String -> ArgsHMap "_sample_normal(symbol)" args -> IO SymbolHandle
-_sample_normal name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),
-               ("sigma",) <$> (args !? #sigma :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_normal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_gamma(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]
-
-_sample_gamma ::
-              forall args . Fullfilled "_sample_gamma(symbol)" args =>
-                String -> ArgsHMap "_sample_gamma(symbol)" args -> IO SymbolHandle
-_sample_gamma name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_exponential(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt SymbolHandle)]
-
-_sample_exponential ::
-                    forall args . Fullfilled "_sample_exponential(symbol)" args =>
-                      String ->
-                        ArgsHMap "_sample_exponential(symbol)" args -> IO SymbolHandle
-_sample_exponential name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_exponential"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_poisson(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("lam", AttrOpt SymbolHandle)]
-
-_sample_poisson ::
-                forall args . Fullfilled "_sample_poisson(symbol)" args =>
-                  String ->
-                    ArgsHMap "_sample_poisson(symbol)" args -> IO SymbolHandle
-_sample_poisson name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("lam",) <$> (args !? #lam :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_poisson"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_negative_binomial(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("k", AttrOpt SymbolHandle), '("p", AttrOpt SymbolHandle)]
-
-_sample_negative_binomial ::
-                          forall args .
-                            Fullfilled "_sample_negative_binomial(symbol)" args =>
-                            String ->
-                              ArgsHMap "_sample_negative_binomial(symbol)" args ->
-                                IO SymbolHandle
-_sample_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("k",) <$> (args !? #k :: Maybe SymbolHandle),
-               ("p",) <$> (args !? #p :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_sample_generalized_negative_binomial(symbol)" =
-     '[ '("shape", AttrOpt [Int]),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
-        '("mu", AttrOpt SymbolHandle), '("alpha", AttrOpt SymbolHandle)]
-
-_sample_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_sample_generalized_negative_binomial(symbol)"
-                                          args =>
-                                        String ->
-                                          ArgsHMap "_sample_generalized_negative_binomial(symbol)"
-                                            args
-                                            -> IO SymbolHandle
-_sample_generalized_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("mu",) <$> (args !? #mu :: Maybe SymbolHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_generalized_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sample_unique_zipfian(symbol)" =
-     '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])]
-
-_sample_unique_zipfian ::
-                       forall args . Fullfilled "_sample_unique_zipfian(symbol)" args =>
-                         String ->
-                           ArgsHMap "_sample_unique_zipfian(symbol)" args -> IO SymbolHandle
-_sample_unique_zipfian name args
-  = let scalarArgs
-          = catMaybes
-              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sample_unique_zipfian"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_uniform(symbol)" =
-     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_uniform ::
-                forall args . Fullfilled "_random_uniform(symbol)" args =>
-                  String ->
-                    ArgsHMap "_random_uniform(symbol)" args -> IO SymbolHandle
-_random_uniform name args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_normal(symbol)" =
-     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_normal ::
-               forall args . Fullfilled "_random_normal(symbol)" args =>
-                 String -> ArgsHMap "_random_normal(symbol)" args -> IO SymbolHandle
-_random_normal name args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_gamma(symbol)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_gamma ::
-              forall args . Fullfilled "_random_gamma(symbol)" args =>
-                String -> ArgsHMap "_random_gamma(symbol)" args -> IO SymbolHandle
-_random_gamma name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_exponential(symbol)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_exponential ::
-                    forall args . Fullfilled "_random_exponential(symbol)" args =>
-                      String ->
-                        ArgsHMap "_random_exponential(symbol)" args -> IO SymbolHandle
-_random_exponential name args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_poisson(symbol)" =
-     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_poisson ::
-                forall args . Fullfilled "_random_poisson(symbol)" args =>
-                  String ->
-                    ArgsHMap "_random_poisson(symbol)" args -> IO SymbolHandle
-_random_poisson name args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_negative_binomial(symbol)" =
-     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_negative_binomial ::
-                          forall args .
-                            Fullfilled "_random_negative_binomial(symbol)" args =>
-                            String ->
-                              ArgsHMap "_random_negative_binomial(symbol)" args ->
-                                IO SymbolHandle
-_random_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_random_generalized_negative_binomial(symbol)" =
-     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
-
-_random_generalized_negative_binomial ::
-                                      forall args .
-                                        Fullfilled "_random_generalized_negative_binomial(symbol)"
-                                          args =>
-                                        String ->
-                                          ArgsHMap "_random_generalized_negative_binomial(symbol)"
-                                            args
-                                            -> IO SymbolHandle
-_random_generalized_negative_binomial name args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_randint(symbol)" =
-     '[ '("low", AttrReq Int), '("high", AttrReq Int),
-        '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype", AttrOpt (EnumType '["None", "int32", "int64"]))]
-
-_random_randint ::
-                forall args . Fullfilled "_random_randint(symbol)" args =>
-                  String ->
-                    ArgsHMap "_random_randint(symbol)" args -> IO SymbolHandle
-_random_randint name args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Int),
-               ("high",) . showValue <$> (args !? #high :: Maybe Int),
-               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype :: Maybe (EnumType '["None", "int32", "int64"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_randint"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_uniform_like(symbol)" =
-     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_random_uniform_like ::
-                     forall args . Fullfilled "_random_uniform_like(symbol)" args =>
-                       String ->
-                         ArgsHMap "_random_uniform_like(symbol)" args -> IO SymbolHandle
-_random_uniform_like name args
-  = let scalarArgs
-          = catMaybes
-              [("low",) . showValue <$> (args !? #low :: Maybe Float),
-               ("high",) . showValue <$> (args !? #high :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_uniform_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_normal_like(symbol)" =
-     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_random_normal_like ::
-                    forall args . Fullfilled "_random_normal_like(symbol)" args =>
-                      String ->
-                        ArgsHMap "_random_normal_like(symbol)" args -> IO SymbolHandle
-_random_normal_like name args
-  = let scalarArgs
-          = catMaybes
-              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
-               ("scale",) . showValue <$> (args !? #scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_normal_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_gamma_like(symbol)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_random_gamma_like ::
-                   forall args . Fullfilled "_random_gamma_like(symbol)" args =>
-                     String ->
-                       ArgsHMap "_random_gamma_like(symbol)" args -> IO SymbolHandle
-_random_gamma_like name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_gamma_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_exponential_like(symbol)" =
-     '[ '("lam", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_random_exponential_like ::
-                         forall args . Fullfilled "_random_exponential_like(symbol)" args =>
-                           String ->
-                             ArgsHMap "_random_exponential_like(symbol)" args -> IO SymbolHandle
-_random_exponential_like name args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_exponential_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_random_poisson_like(symbol)" =
-     '[ '("lam", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_random_poisson_like ::
-                     forall args . Fullfilled "_random_poisson_like(symbol)" args =>
-                       String ->
-                         ArgsHMap "_random_poisson_like(symbol)" args -> IO SymbolHandle
-_random_poisson_like name args
-  = let scalarArgs
-          = catMaybes
-              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_poisson_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_random_negative_binomial_like(symbol)" =
-     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_random_negative_binomial_like ::
-                               forall args .
-                                 Fullfilled "_random_negative_binomial_like(symbol)" args =>
-                                 String ->
-                                   ArgsHMap "_random_negative_binomial_like(symbol)" args ->
-                                     IO SymbolHandle
-_random_negative_binomial_like name args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_negative_binomial_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_random_generalized_negative_binomial_like(symbol)"
-     =
-     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_random_generalized_negative_binomial_like ::
-                                           forall args .
-                                             Fullfilled
-                                               "_random_generalized_negative_binomial_like(symbol)"
-                                               args =>
-                                             String ->
-                                               ArgsHMap
-                                                 "_random_generalized_negative_binomial_like(symbol)"
-                                                 args
-                                                 -> IO SymbolHandle
-_random_generalized_negative_binomial_like name args
-  = let scalarArgs
-          = catMaybes
-              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_random_generalized_negative_binomial_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_shuffle(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_shuffle ::
-         forall args . Fullfilled "_shuffle(symbol)" args =>
-           String -> ArgsHMap "_shuffle(symbol)" args -> IO SymbolHandle
-_shuffle name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_shuffle"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Custom(symbol)" =
-     '[ '("op_type", AttrOpt String), '("data", AttrOpt [SymbolHandle])]
-
-_Custom ::
-        forall args .
-          (Fullfilled "_Custom(symbol)" args,
-           PopKey (ArgOf "_Custom(symbol)") args "data",
-           Dump (PopResult (ArgOf "_Custom(symbol)") args "data")) =>
-          String -> ArgsHMap "_Custom(symbol)" args -> IO SymbolHandle
-_Custom name args
-  = let scalarArgs = dump (pop args #data)
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "Custom"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_Custom(symbol)" = '[]
-
-_backward_Custom ::
-                 forall args . Fullfilled "_backward_Custom(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_Custom(symbol)" args -> IO SymbolHandle
-_backward_Custom name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Custom"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_power(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_power ::
-                forall args . Fullfilled "broadcast_power(symbol)" args =>
-                  String ->
-                    ArgsHMap "broadcast_power(symbol)" args -> IO SymbolHandle
-broadcast_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_power(symbol)" =
-     '[]
-
-_backward_broadcast_power ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_power(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_broadcast_power(symbol)" args ->
-                                IO SymbolHandle
-_backward_broadcast_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_maximum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_maximum ::
-                  forall args . Fullfilled "broadcast_maximum(symbol)" args =>
-                    String ->
-                      ArgsHMap "broadcast_maximum(symbol)" args -> IO SymbolHandle
-broadcast_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_maximum(symbol)" =
-     '[]
-
-_backward_broadcast_maximum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_maximum(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_broadcast_maximum(symbol)" args ->
-                                  IO SymbolHandle
-_backward_broadcast_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_minimum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_minimum ::
-                  forall args . Fullfilled "broadcast_minimum(symbol)" args =>
-                    String ->
-                      ArgsHMap "broadcast_minimum(symbol)" args -> IO SymbolHandle
-broadcast_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_minimum(symbol)" =
-     '[]
-
-_backward_broadcast_minimum ::
-                            forall args .
-                              Fullfilled "_backward_broadcast_minimum(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_broadcast_minimum(symbol)" args ->
-                                  IO SymbolHandle
-_backward_broadcast_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_hypot(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_hypot ::
-                forall args . Fullfilled "broadcast_hypot(symbol)" args =>
-                  String ->
-                    ArgsHMap "broadcast_hypot(symbol)" args -> IO SymbolHandle
-broadcast_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_hypot(symbol)" =
-     '[]
-
-_backward_broadcast_hypot ::
-                          forall args .
-                            Fullfilled "_backward_broadcast_hypot(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_broadcast_hypot(symbol)" args ->
-                                IO SymbolHandle
-_backward_broadcast_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_equal ::
-       forall args . Fullfilled "_equal(symbol)" args =>
-         String -> ArgsHMap "_equal(symbol)" args -> IO SymbolHandle
-_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_not_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_not_equal ::
-           forall args . Fullfilled "_not_equal(symbol)" args =>
-             String -> ArgsHMap "_not_equal(symbol)" args -> IO SymbolHandle
-_not_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_greater ::
-         forall args . Fullfilled "_greater(symbol)" args =>
-           String -> ArgsHMap "_greater(symbol)" args -> IO SymbolHandle
-_greater name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_greater_equal ::
-               forall args . Fullfilled "_greater_equal(symbol)" args =>
-                 String -> ArgsHMap "_greater_equal(symbol)" args -> IO SymbolHandle
-_greater_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_lesser ::
-        forall args . Fullfilled "_lesser(symbol)" args =>
-          String -> ArgsHMap "_lesser(symbol)" args -> IO SymbolHandle
-_lesser name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_lesser_equal ::
-              forall args . Fullfilled "_lesser_equal(symbol)" args =>
-                String -> ArgsHMap "_lesser_equal(symbol)" args -> IO SymbolHandle
-_lesser_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_and(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_logical_and ::
-             forall args . Fullfilled "_logical_and(symbol)" args =>
-               String -> ArgsHMap "_logical_and(symbol)" args -> IO SymbolHandle
-_logical_and name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_or(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_logical_or ::
-            forall args . Fullfilled "_logical_or(symbol)" args =>
-              String -> ArgsHMap "_logical_or(symbol)" args -> IO SymbolHandle
-_logical_or name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_xor(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_logical_xor ::
-             forall args . Fullfilled "_logical_xor(symbol)" args =>
-               String -> ArgsHMap "_logical_xor(symbol)" args -> IO SymbolHandle
-_logical_xor name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_power(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_power ::
-       forall args . Fullfilled "_power(symbol)" args =>
-         String -> ArgsHMap "_power(symbol)" args -> IO SymbolHandle
-_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_power(symbol)" = '[]
-
-_backward_power ::
-                forall args . Fullfilled "_backward_power(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_power(symbol)" args -> IO SymbolHandle
-_backward_power name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_maximum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_maximum ::
-         forall args . Fullfilled "_maximum(symbol)" args =>
-           String -> ArgsHMap "_maximum(symbol)" args -> IO SymbolHandle
-_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_maximum(symbol)" = '[]
-
-_backward_maximum ::
-                  forall args . Fullfilled "_backward_maximum(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_maximum(symbol)" args -> IO SymbolHandle
-_backward_maximum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_minimum(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_minimum ::
-         forall args . Fullfilled "_minimum(symbol)" args =>
-           String -> ArgsHMap "_minimum(symbol)" args -> IO SymbolHandle
-_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_minimum(symbol)" = '[]
-
-_backward_minimum ::
-                  forall args . Fullfilled "_backward_minimum(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_minimum(symbol)" args -> IO SymbolHandle
-_backward_minimum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_hypot(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_hypot ::
-       forall args . Fullfilled "_hypot(symbol)" args =>
-         String -> ArgsHMap "_hypot(symbol)" args -> IO SymbolHandle
-_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_hypot(symbol)" = '[]
-
-_backward_hypot ::
-                forall args . Fullfilled "_backward_hypot(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_hypot(symbol)" args -> IO SymbolHandle
-_backward_hypot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_square_sum(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-_square_sum ::
-            forall args . Fullfilled "_square_sum(symbol)" args =>
-              String -> ArgsHMap "_square_sum(symbol)" args -> IO SymbolHandle
-_square_sum name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_square_sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_square_sum(symbol)" = '[]
-
-_backward_square_sum ::
-                     forall args . Fullfilled "_backward_square_sum(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_square_sum(symbol)" args -> IO SymbolHandle
-_backward_square_sum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square_sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "add_n(symbol)" =
-     '[ '("args", AttrOpt [SymbolHandle])]
-
-add_n ::
-      forall args . Fullfilled "add_n(symbol)" args =>
-        String -> ArgsHMap "add_n(symbol)" args -> IO SymbolHandle
-add_n name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "add_n"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_zeros_without_dtype(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype", AttrOpt Int)]
-
-_zeros_without_dtype ::
-                     forall args . Fullfilled "_zeros_without_dtype(symbol)" args =>
-                       String ->
-                         ArgsHMap "_zeros_without_dtype(symbol)" args -> IO SymbolHandle
-_zeros_without_dtype name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros_without_dtype"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_zeros(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_zeros ::
-       forall args . Fullfilled "_zeros(symbol)" args =>
-         String -> ArgsHMap "_zeros(symbol)" args -> IO SymbolHandle
-_zeros name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_zeros"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_eye(symbol)" =
-     '[ '("_N", AttrReq Int), '("_M", AttrOpt Int), '("k", AttrOpt Int),
-        '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_eye ::
-     forall args . Fullfilled "_eye(symbol)" args =>
-       String -> ArgsHMap "_eye(symbol)" args -> IO SymbolHandle
-_eye name args
-  = let scalarArgs
-          = catMaybes
-              [("_N",) . showValue <$> (args !? #_N :: Maybe Int),
-               ("_M",) . showValue <$> (args !? #_M :: Maybe Int),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_eye"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_ones(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_ones ::
-      forall args . Fullfilled "_ones(symbol)" args =>
-        String -> ArgsHMap "_ones(symbol)" args -> IO SymbolHandle
-_ones name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ones"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_full(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("value", AttrReq Double)]
-
-_full ::
-      forall args . Fullfilled "_full(symbol)" args =>
-        String -> ArgsHMap "_full(symbol)" args -> IO SymbolHandle
-_full name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("value",) . showValue <$> (args !? #value :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_full"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_arange(symbol)" =
-     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),
-        '("step", AttrOpt Double), '("repeat", AttrOpt Int),
-        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_arange ::
-        forall args . Fullfilled "_arange(symbol)" args =>
-          String -> ArgsHMap "_arange(symbol)" args -> IO SymbolHandle
-_arange name args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("infer_range",) . showValue <$>
-                 (args !? #infer_range :: Maybe Bool),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_arange"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linspace(symbol)" =
-     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),
-        '("step", AttrOpt Double), '("repeat", AttrOpt Int),
-        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt String),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"]))]
-
-_linspace ::
-          forall args . Fullfilled "_linspace(symbol)" args =>
-            String -> ArgsHMap "_linspace(symbol)" args -> IO SymbolHandle
-_linspace name args
-  = let scalarArgs
-          = catMaybes
-              [("start",) . showValue <$> (args !? #start :: Maybe Double),
-               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
-               ("step",) . showValue <$> (args !? #step :: Maybe Double),
-               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
-               ("infer_range",) . showValue <$>
-                 (args !? #infer_range :: Maybe Bool),
-               ("ctx",) . showValue <$> (args !? #ctx :: Maybe String),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linspace"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "zeros_like(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-zeros_like ::
-           forall args . Fullfilled "zeros_like(symbol)" args =>
-             String -> ArgsHMap "zeros_like(symbol)" args -> IO SymbolHandle
-zeros_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "zeros_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ones_like(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-ones_like ::
-          forall args . Fullfilled "ones_like(symbol)" args =>
-            String -> ArgsHMap "ones_like(symbol)" args -> IO SymbolHandle
-ones_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ones_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_add(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_add ::
-              forall args . Fullfilled "broadcast_add(symbol)" args =>
-                String -> ArgsHMap "broadcast_add(symbol)" args -> IO SymbolHandle
-broadcast_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_add(symbol)" = '[]
-
-_backward_broadcast_add ::
-                        forall args . Fullfilled "_backward_broadcast_add(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_add(symbol)" args -> IO SymbolHandle
-_backward_broadcast_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_sub(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_sub ::
-              forall args . Fullfilled "broadcast_sub(symbol)" args =>
-                String -> ArgsHMap "broadcast_sub(symbol)" args -> IO SymbolHandle
-broadcast_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_sub(symbol)" = '[]
-
-_backward_broadcast_sub ::
-                        forall args . Fullfilled "_backward_broadcast_sub(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_sub(symbol)" args -> IO SymbolHandle
-_backward_broadcast_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_mul(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_mul ::
-              forall args . Fullfilled "broadcast_mul(symbol)" args =>
-                String -> ArgsHMap "broadcast_mul(symbol)" args -> IO SymbolHandle
-broadcast_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_mul(symbol)" = '[]
-
-_backward_broadcast_mul ::
-                        forall args . Fullfilled "_backward_broadcast_mul(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_mul(symbol)" args -> IO SymbolHandle
-_backward_broadcast_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_div(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_div ::
-              forall args . Fullfilled "broadcast_div(symbol)" args =>
-                String -> ArgsHMap "broadcast_div(symbol)" args -> IO SymbolHandle
-broadcast_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_div(symbol)" = '[]
-
-_backward_broadcast_div ::
-                        forall args . Fullfilled "_backward_broadcast_div(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_div(symbol)" args -> IO SymbolHandle
-_backward_broadcast_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_mod(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_mod ::
-              forall args . Fullfilled "broadcast_mod(symbol)" args =>
-                String -> ArgsHMap "broadcast_mod(symbol)" args -> IO SymbolHandle
-broadcast_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_broadcast_mod(symbol)" = '[]
-
-_backward_broadcast_mod ::
-                        forall args . Fullfilled "_backward_broadcast_mod(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_broadcast_mod(symbol)" args -> IO SymbolHandle
-_backward_broadcast_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_broadcast_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_gemm(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),
-        '("axis", AttrOpt Int), '("_A", AttrOpt SymbolHandle),
-        '("_B", AttrOpt SymbolHandle), '("_C", AttrOpt SymbolHandle)]
-
-_linalg_gemm ::
-             forall args . Fullfilled "_linalg_gemm(symbol)" args =>
-               String -> ArgsHMap "_linalg_gemm(symbol)" args -> IO SymbolHandle
-_linalg_gemm name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle),
-               ("_C",) <$> (args !? #_C :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_gemm(symbol)" = '[]
-
-_backward_linalg_gemm ::
-                      forall args . Fullfilled "_backward_linalg_gemm(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_gemm(symbol)" args -> IO SymbolHandle
-_backward_linalg_gemm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_gemm2(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("alpha", AttrOpt Double), '("axis", AttrOpt Int),
-        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)]
-
-_linalg_gemm2 ::
-              forall args . Fullfilled "_linalg_gemm2(symbol)" args =>
-                String -> ArgsHMap "_linalg_gemm2(symbol)" args -> IO SymbolHandle
-_linalg_gemm2 name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gemm2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_gemm2(symbol)" = '[]
-
-_backward_linalg_gemm2 ::
-                       forall args . Fullfilled "_backward_linalg_gemm2(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_gemm2(symbol)" args -> IO SymbolHandle
-_backward_linalg_gemm2 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gemm2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_potrf(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_potrf ::
-              forall args . Fullfilled "_linalg_potrf(symbol)" args =>
-                String -> ArgsHMap "_linalg_potrf(symbol)" args -> IO SymbolHandle
-_linalg_potrf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potrf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_potrf(symbol)" = '[]
-
-_backward_linalg_potrf ::
-                       forall args . Fullfilled "_backward_linalg_potrf(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_potrf(symbol)" args -> IO SymbolHandle
-_backward_linalg_potrf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potrf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_potri(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_potri ::
-              forall args . Fullfilled "_linalg_potri(symbol)" args =>
-                String -> ArgsHMap "_linalg_potri(symbol)" args -> IO SymbolHandle
-_linalg_potri name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_potri"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_potri(symbol)" = '[]
-
-_backward_linalg_potri ::
-                       forall args . Fullfilled "_backward_linalg_potri(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_potri(symbol)" args -> IO SymbolHandle
-_backward_linalg_potri name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_potri"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_trmm(symbol)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)]
-
-_linalg_trmm ::
-             forall args . Fullfilled "_linalg_trmm(symbol)" args =>
-               String -> ArgsHMap "_linalg_trmm(symbol)" args -> IO SymbolHandle
-_linalg_trmm name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trmm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_trmm(symbol)" = '[]
-
-_backward_linalg_trmm ::
-                      forall args . Fullfilled "_backward_linalg_trmm(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_trmm(symbol)" args -> IO SymbolHandle
-_backward_linalg_trmm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trmm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_trsm(symbol)" =
-     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
-        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt SymbolHandle), '("_B", AttrOpt SymbolHandle)]
-
-_linalg_trsm ::
-             forall args . Fullfilled "_linalg_trsm(symbol)" args =>
-               String -> ArgsHMap "_linalg_trsm(symbol)" args -> IO SymbolHandle
-_linalg_trsm name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("_A",) <$> (args !? #_A :: Maybe SymbolHandle),
-               ("_B",) <$> (args !? #_B :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_trsm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_trsm(symbol)" = '[]
-
-_backward_linalg_trsm ::
-                      forall args . Fullfilled "_backward_linalg_trsm(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_trsm(symbol)" args -> IO SymbolHandle
-_backward_linalg_trsm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_trsm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_sumlogdiag(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_sumlogdiag ::
-                   forall args . Fullfilled "_linalg_sumlogdiag(symbol)" args =>
-                     String ->
-                       ArgsHMap "_linalg_sumlogdiag(symbol)" args -> IO SymbolHandle
-_linalg_sumlogdiag name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_sumlogdiag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_sumlogdiag(symbol)" =
-     '[]
-
-_backward_linalg_sumlogdiag ::
-                            forall args .
-                              Fullfilled "_backward_linalg_sumlogdiag(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_linalg_sumlogdiag(symbol)" args ->
-                                  IO SymbolHandle
-_backward_linalg_sumlogdiag name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_sumlogdiag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_extractdiag(symbol)" =
-     '[ '("offset", AttrOpt Int), '("_A", AttrOpt SymbolHandle)]
-
-_linalg_extractdiag ::
-                    forall args . Fullfilled "_linalg_extractdiag(symbol)" args =>
-                      String ->
-                        ArgsHMap "_linalg_extractdiag(symbol)" args -> IO SymbolHandle
-_linalg_extractdiag name args
-  = let scalarArgs
-          = catMaybes
-              [("offset",) . showValue <$> (args !? #offset :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_extractdiag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_extractdiag(symbol)"
-     = '[]
-
-_backward_linalg_extractdiag ::
-                             forall args .
-                               Fullfilled "_backward_linalg_extractdiag(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_backward_linalg_extractdiag(symbol)" args ->
-                                   IO SymbolHandle
-_backward_linalg_extractdiag name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_extractdiag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_makediag(symbol)" =
-     '[ '("offset", AttrOpt Int), '("_A", AttrOpt SymbolHandle)]
-
-_linalg_makediag ::
-                 forall args . Fullfilled "_linalg_makediag(symbol)" args =>
-                   String ->
-                     ArgsHMap "_linalg_makediag(symbol)" args -> IO SymbolHandle
-_linalg_makediag name args
-  = let scalarArgs
-          = catMaybes
-              [("offset",) . showValue <$> (args !? #offset :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_makediag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_makediag(symbol)" =
-     '[]
-
-_backward_linalg_makediag ::
-                          forall args .
-                            Fullfilled "_backward_linalg_makediag(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_linalg_makediag(symbol)" args ->
-                                IO SymbolHandle
-_backward_linalg_makediag name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_makediag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_extracttrian(symbol)" =
-     '[ '("offset", AttrOpt Int), '("lower", AttrOpt Bool),
-        '("_A", AttrOpt SymbolHandle)]
-
-_linalg_extracttrian ::
-                     forall args . Fullfilled "_linalg_extracttrian(symbol)" args =>
-                       String ->
-                         ArgsHMap "_linalg_extracttrian(symbol)" args -> IO SymbolHandle
-_linalg_extracttrian name args
-  = let scalarArgs
-          = catMaybes
-              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_extracttrian"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_extracttrian(symbol)"
-     = '[]
-
-_backward_linalg_extracttrian ::
-                              forall args .
-                                Fullfilled "_backward_linalg_extracttrian(symbol)" args =>
-                                String ->
-                                  ArgsHMap "_backward_linalg_extracttrian(symbol)" args ->
-                                    IO SymbolHandle
-_backward_linalg_extracttrian name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_extracttrian"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_maketrian(symbol)" =
-     '[ '("offset", AttrOpt Int), '("lower", AttrOpt Bool),
-        '("_A", AttrOpt SymbolHandle)]
-
-_linalg_maketrian ::
-                  forall args . Fullfilled "_linalg_maketrian(symbol)" args =>
-                    String ->
-                      ArgsHMap "_linalg_maketrian(symbol)" args -> IO SymbolHandle
-_linalg_maketrian name args
-  = let scalarArgs
-          = catMaybes
-              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),
-               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_maketrian"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_maketrian(symbol)" =
-     '[]
-
-_backward_linalg_maketrian ::
-                           forall args .
-                             Fullfilled "_backward_linalg_maketrian(symbol)" args =>
-                             String ->
-                               ArgsHMap "_backward_linalg_maketrian(symbol)" args ->
-                                 IO SymbolHandle
-_backward_linalg_maketrian name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_maketrian"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_syrk(symbol)" =
-     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),
-        '("_A", AttrOpt SymbolHandle)]
-
-_linalg_syrk ::
-             forall args . Fullfilled "_linalg_syrk(symbol)" args =>
-               String -> ArgsHMap "_linalg_syrk(symbol)" args -> IO SymbolHandle
-_linalg_syrk name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
-               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syrk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_syrk(symbol)" = '[]
-
-_backward_linalg_syrk ::
-                      forall args . Fullfilled "_backward_linalg_syrk(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_linalg_syrk(symbol)" args -> IO SymbolHandle
-_backward_linalg_syrk name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syrk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_gelqf(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_gelqf ::
-              forall args . Fullfilled "_linalg_gelqf(symbol)" args =>
-                String -> ArgsHMap "_linalg_gelqf(symbol)" args -> IO SymbolHandle
-_linalg_gelqf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_gelqf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_gelqf(symbol)" = '[]
-
-_backward_linalg_gelqf ::
-                       forall args . Fullfilled "_backward_linalg_gelqf(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_gelqf(symbol)" args -> IO SymbolHandle
-_backward_linalg_gelqf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_gelqf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_syevd(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_syevd ::
-              forall args . Fullfilled "_linalg_syevd(symbol)" args =>
-                String -> ArgsHMap "_linalg_syevd(symbol)" args -> IO SymbolHandle
-_linalg_syevd name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_syevd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_syevd(symbol)" = '[]
-
-_backward_linalg_syevd ::
-                       forall args . Fullfilled "_backward_linalg_syevd(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_linalg_syevd(symbol)" args -> IO SymbolHandle
-_backward_linalg_syevd name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_syevd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_linalg_inverse(symbol)" =
-     '[ '("_A", AttrOpt SymbolHandle)]
-
-_linalg_inverse ::
-                forall args . Fullfilled "_linalg_inverse(symbol)" args =>
-                  String ->
-                    ArgsHMap "_linalg_inverse(symbol)" args -> IO SymbolHandle
-_linalg_inverse name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("_A",) <$> (args !? #_A :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_linalg_inverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linalg_inverse(symbol)" =
-     '[]
-
-_backward_linalg_inverse ::
-                         forall args . Fullfilled "_backward_linalg_inverse(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_linalg_inverse(symbol)" args -> IO SymbolHandle
-_backward_linalg_inverse name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linalg_inverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_histogram(symbol)" =
-     '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle), '("bins", AttrOpt SymbolHandle)]
-
-_histogram ::
-           forall args . Fullfilled "_histogram(symbol)" args =>
-             String -> ArgsHMap "_histogram(symbol)" args -> IO SymbolHandle
-_histogram name args
-  = let scalarArgs
-          = catMaybes
-              [("bin_cnt",) . showValue <$>
-                 (args !? #bin_cnt :: Maybe (Maybe Int)),
-               ("range",) . showValue <$> (args !? #range :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("bins",) <$> (args !? #bins :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_histogram"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cast_storage(symbol)" =
-     '[ '("stype",
-          AttrReq (EnumType '["csr", "default", "row_sparse"])),
-        '("data", AttrOpt SymbolHandle)]
-
-cast_storage ::
-             forall args . Fullfilled "cast_storage(symbol)" args =>
-               String -> ArgsHMap "cast_storage(symbol)" args -> IO SymbolHandle
-cast_storage name args
-  = let scalarArgs
-          = catMaybes
-              [("stype",) . showValue <$>
-                 (args !? #stype ::
-                    Maybe (EnumType '["csr", "default", "row_sparse"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cast_storage"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_equal_scalar ::
-              forall args . Fullfilled "_equal_scalar(symbol)" args =>
-                String -> ArgsHMap "_equal_scalar(symbol)" args -> IO SymbolHandle
-_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_not_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_not_equal_scalar ::
-                  forall args . Fullfilled "_not_equal_scalar(symbol)" args =>
-                    String ->
-                      ArgsHMap "_not_equal_scalar(symbol)" args -> IO SymbolHandle
-_not_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_not_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_greater_scalar ::
-                forall args . Fullfilled "_greater_scalar(symbol)" args =>
-                  String ->
-                    ArgsHMap "_greater_scalar(symbol)" args -> IO SymbolHandle
-_greater_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_greater_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_greater_equal_scalar ::
-                      forall args . Fullfilled "_greater_equal_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_greater_equal_scalar(symbol)" args -> IO SymbolHandle
-_greater_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_greater_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_lesser_scalar ::
-               forall args . Fullfilled "_lesser_scalar(symbol)" args =>
-                 String -> ArgsHMap "_lesser_scalar(symbol)" args -> IO SymbolHandle
-_lesser_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_lesser_equal_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_lesser_equal_scalar ::
-                     forall args . Fullfilled "_lesser_equal_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_lesser_equal_scalar(symbol)" args -> IO SymbolHandle
-_lesser_equal_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_lesser_equal_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_and_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_logical_and_scalar ::
-                    forall args . Fullfilled "_logical_and_scalar(symbol)" args =>
-                      String ->
-                        ArgsHMap "_logical_and_scalar(symbol)" args -> IO SymbolHandle
-_logical_and_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_and_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_or_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_logical_or_scalar ::
-                   forall args . Fullfilled "_logical_or_scalar(symbol)" args =>
-                     String ->
-                       ArgsHMap "_logical_or_scalar(symbol)" args -> IO SymbolHandle
-_logical_or_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_or_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_logical_xor_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_logical_xor_scalar ::
-                    forall args . Fullfilled "_logical_xor_scalar(symbol)" args =>
-                      String ->
-                        ArgsHMap "_logical_xor_scalar(symbol)" args -> IO SymbolHandle
-_logical_xor_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_logical_xor_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "relu(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-relu ::
-     forall args . Fullfilled "relu(symbol)" args =>
-       String -> ArgsHMap "relu(symbol)" args -> IO SymbolHandle
-relu name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "relu"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_relu(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_relu ::
-               forall args . Fullfilled "_backward_relu(symbol)" args =>
-                 String -> ArgsHMap "_backward_relu(symbol)" args -> IO SymbolHandle
-_backward_relu name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_relu"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sigmoid(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sigmoid ::
-        forall args . Fullfilled "sigmoid(symbol)" args =>
-          String -> ArgsHMap "sigmoid(symbol)" args -> IO SymbolHandle
-sigmoid name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sigmoid"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sigmoid(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sigmoid ::
-                  forall args . Fullfilled "_backward_sigmoid(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_sigmoid(symbol)" args -> IO SymbolHandle
-_backward_sigmoid name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sigmoid"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "hard_sigmoid(symbol)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-hard_sigmoid ::
-             forall args . Fullfilled "hard_sigmoid(symbol)" args =>
-               String -> ArgsHMap "hard_sigmoid(symbol)" args -> IO SymbolHandle
-hard_sigmoid name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "hard_sigmoid"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_hard_sigmoid(symbol)" = '[]
-
-_backward_hard_sigmoid ::
-                       forall args . Fullfilled "_backward_hard_sigmoid(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_hard_sigmoid(symbol)" args -> IO SymbolHandle
-_backward_hard_sigmoid name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hard_sigmoid"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "softsign(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-softsign ::
-         forall args . Fullfilled "softsign(symbol)" args =>
-           String -> ArgsHMap "softsign(symbol)" args -> IO SymbolHandle
-softsign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softsign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_softsign(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_softsign ::
-                   forall args . Fullfilled "_backward_softsign(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_softsign(symbol)" args -> IO SymbolHandle
-_backward_softsign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softsign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_copy(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_copy ::
-      forall args . Fullfilled "_copy(symbol)" args =>
-        String -> ArgsHMap "_copy(symbol)" args -> IO SymbolHandle
-_copy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_copy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_copy(symbol)" = '[]
-
-_backward_copy ::
-               forall args . Fullfilled "_backward_copy(symbol)" args =>
-                 String -> ArgsHMap "_backward_copy(symbol)" args -> IO SymbolHandle
-_backward_copy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_copy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_reshape(symbol)" = '[]
-
-_backward_reshape ::
-                  forall args . Fullfilled "_backward_reshape(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_reshape(symbol)" args -> IO SymbolHandle
-_backward_reshape name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reshape"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BlockGrad(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_BlockGrad ::
-           forall args . Fullfilled "_BlockGrad(symbol)" args =>
-             String -> ArgsHMap "_BlockGrad(symbol)" args -> IO SymbolHandle
-_BlockGrad name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BlockGrad"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "make_loss(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-make_loss ::
-          forall args . Fullfilled "make_loss(symbol)" args =>
-            String -> ArgsHMap "make_loss(symbol)" args -> IO SymbolHandle
-make_loss name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "make_loss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_identity_with_attr_like_rhs(symbol)"
-     =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_identity_with_attr_like_rhs ::
-                             forall args .
-                               Fullfilled "_identity_with_attr_like_rhs(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_identity_with_attr_like_rhs(symbol)" args ->
-                                   IO SymbolHandle
-_identity_with_attr_like_rhs name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_identity_with_attr_like_rhs"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "reshape_like(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-reshape_like ::
-             forall args . Fullfilled "reshape_like(symbol)" args =>
-               String -> ArgsHMap "reshape_like(symbol)" args -> IO SymbolHandle
-reshape_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reshape_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "shape_array(symbol)" =
-     '[ '("lhs_begin", AttrOpt (Maybe Int)),
-        '("lhs_end", AttrOpt (Maybe Int)),
-        '("rhs_begin", AttrOpt (Maybe Int)),
-        '("rhs_end", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)]
-
-shape_array ::
-            forall args . Fullfilled "shape_array(symbol)" args =>
-              String -> ArgsHMap "shape_array(symbol)" args -> IO SymbolHandle
-shape_array name args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_begin",) . showValue <$>
-                 (args !? #lhs_begin :: Maybe (Maybe Int)),
-               ("lhs_end",) . showValue <$>
-                 (args !? #lhs_end :: Maybe (Maybe Int)),
-               ("rhs_begin",) . showValue <$>
-                 (args !? #rhs_begin :: Maybe (Maybe Int)),
-               ("rhs_end",) . showValue <$>
-                 (args !? #rhs_end :: Maybe (Maybe Int))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "shape_array"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "size_array(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-size_array ::
-           forall args . Fullfilled "size_array(symbol)" args =>
-             String -> ArgsHMap "size_array(symbol)" args -> IO SymbolHandle
-size_array name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "size_array"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Cast(symbol)" =
-     '[ '("dtype",
-          AttrReq
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_Cast ::
-      forall args . Fullfilled "_Cast(symbol)" args =>
-        String -> ArgsHMap "_Cast(symbol)" args -> IO SymbolHandle
-_Cast name args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Cast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cast(symbol)" = '[]
-
-_backward_cast ::
-               forall args . Fullfilled "_backward_cast(symbol)" args =>
-                 String -> ArgsHMap "_backward_cast(symbol)" args -> IO SymbolHandle
-_backward_cast name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "negative(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-negative ::
-         forall args . Fullfilled "negative(symbol)" args =>
-           String -> ArgsHMap "negative(symbol)" args -> IO SymbolHandle
-negative name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "negative"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "reciprocal(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-reciprocal ::
-           forall args . Fullfilled "reciprocal(symbol)" args =>
-             String -> ArgsHMap "reciprocal(symbol)" args -> IO SymbolHandle
-reciprocal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reciprocal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_reciprocal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_reciprocal ::
-                     forall args . Fullfilled "_backward_reciprocal(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_reciprocal(symbol)" args -> IO SymbolHandle
-_backward_reciprocal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reciprocal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "abs(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-abs ::
-    forall args . Fullfilled "abs(symbol)" args =>
-      String -> ArgsHMap "abs(symbol)" args -> IO SymbolHandle
-abs name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "abs"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_abs(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_abs ::
-              forall args . Fullfilled "_backward_abs(symbol)" args =>
-                String -> ArgsHMap "_backward_abs(symbol)" args -> IO SymbolHandle
-_backward_abs name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_abs"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sign(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sign ::
-     forall args . Fullfilled "sign(symbol)" args =>
-       String -> ArgsHMap "sign(symbol)" args -> IO SymbolHandle
-sign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sign(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sign ::
-               forall args . Fullfilled "_backward_sign(symbol)" args =>
-                 String -> ArgsHMap "_backward_sign(symbol)" args -> IO SymbolHandle
-_backward_sign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "round(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-round ::
-      forall args . Fullfilled "round(symbol)" args =>
-        String -> ArgsHMap "round(symbol)" args -> IO SymbolHandle
-round name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "round"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rint(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-rint ::
-     forall args . Fullfilled "rint(symbol)" args =>
-       String -> ArgsHMap "rint(symbol)" args -> IO SymbolHandle
-rint name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rint"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ceil(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-ceil ::
-     forall args . Fullfilled "ceil(symbol)" args =>
-       String -> ArgsHMap "ceil(symbol)" args -> IO SymbolHandle
-ceil name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ceil"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "floor(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-floor ::
-      forall args . Fullfilled "floor(symbol)" args =>
-        String -> ArgsHMap "floor(symbol)" args -> IO SymbolHandle
-floor name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "floor"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "trunc(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-trunc ::
-      forall args . Fullfilled "trunc(symbol)" args =>
-        String -> ArgsHMap "trunc(symbol)" args -> IO SymbolHandle
-trunc name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "trunc"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "fix(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-fix ::
-    forall args . Fullfilled "fix(symbol)" args =>
-      String -> ArgsHMap "fix(symbol)" args -> IO SymbolHandle
-fix name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "fix"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "square(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-square ::
-       forall args . Fullfilled "square(symbol)" args =>
-         String -> ArgsHMap "square(symbol)" args -> IO SymbolHandle
-square name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "square"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_square(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_square ::
-                 forall args . Fullfilled "_backward_square(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_square(symbol)" args -> IO SymbolHandle
-_backward_square name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_square"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sqrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sqrt ::
-     forall args . Fullfilled "sqrt(symbol)" args =>
-       String -> ArgsHMap "sqrt(symbol)" args -> IO SymbolHandle
-sqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sqrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sqrt ::
-               forall args . Fullfilled "_backward_sqrt(symbol)" args =>
-                 String -> ArgsHMap "_backward_sqrt(symbol)" args -> IO SymbolHandle
-_backward_sqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rsqrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-rsqrt ::
-      forall args . Fullfilled "rsqrt(symbol)" args =>
-        String -> ArgsHMap "rsqrt(symbol)" args -> IO SymbolHandle
-rsqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rsqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rsqrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rsqrt ::
-                forall args . Fullfilled "_backward_rsqrt(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_rsqrt(symbol)" args -> IO SymbolHandle
-_backward_rsqrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rsqrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cbrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-cbrt ::
-     forall args . Fullfilled "cbrt(symbol)" args =>
-       String -> ArgsHMap "cbrt(symbol)" args -> IO SymbolHandle
-cbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cbrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_cbrt ::
-               forall args . Fullfilled "_backward_cbrt(symbol)" args =>
-                 String -> ArgsHMap "_backward_cbrt(symbol)" args -> IO SymbolHandle
-_backward_cbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "erf(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-erf ::
-    forall args . Fullfilled "erf(symbol)" args =>
-      String -> ArgsHMap "erf(symbol)" args -> IO SymbolHandle
-erf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "erf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_erf(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_erf ::
-              forall args . Fullfilled "_backward_erf(symbol)" args =>
-                String -> ArgsHMap "_backward_erf(symbol)" args -> IO SymbolHandle
-_backward_erf name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_erf"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "erfinv(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-erfinv ::
-       forall args . Fullfilled "erfinv(symbol)" args =>
-         String -> ArgsHMap "erfinv(symbol)" args -> IO SymbolHandle
-erfinv name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "erfinv"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_erfinv(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_erfinv ::
-                 forall args . Fullfilled "_backward_erfinv(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_erfinv(symbol)" args -> IO SymbolHandle
-_backward_erfinv name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_erfinv"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rcbrt(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-rcbrt ::
-      forall args . Fullfilled "rcbrt(symbol)" args =>
-        String -> ArgsHMap "rcbrt(symbol)" args -> IO SymbolHandle
-rcbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rcbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rcbrt(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rcbrt ::
-                forall args . Fullfilled "_backward_rcbrt(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_rcbrt(symbol)" args -> IO SymbolHandle
-_backward_rcbrt name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rcbrt"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "exp(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-exp ::
-    forall args . Fullfilled "exp(symbol)" args =>
-      String -> ArgsHMap "exp(symbol)" args -> IO SymbolHandle
-exp name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "exp"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log ::
-    forall args . Fullfilled "log(symbol)" args =>
-      String -> ArgsHMap "log(symbol)" args -> IO SymbolHandle
-log name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log10(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log10 ::
-      forall args . Fullfilled "log10(symbol)" args =>
-        String -> ArgsHMap "log10(symbol)" args -> IO SymbolHandle
-log10 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log10"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log2(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log2 ::
-     forall args . Fullfilled "log2(symbol)" args =>
-       String -> ArgsHMap "log2(symbol)" args -> IO SymbolHandle
-log2 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log ::
-              forall args . Fullfilled "_backward_log(symbol)" args =>
-                String -> ArgsHMap "_backward_log(symbol)" args -> IO SymbolHandle
-_backward_log name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log10(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log10 ::
-                forall args . Fullfilled "_backward_log10(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_log10(symbol)" args -> IO SymbolHandle
-_backward_log10 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log10"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log2(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log2 ::
-               forall args . Fullfilled "_backward_log2(symbol)" args =>
-                 String -> ArgsHMap "_backward_log2(symbol)" args -> IO SymbolHandle
-_backward_log2 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "log1p(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-log1p ::
-      forall args . Fullfilled "log1p(symbol)" args =>
-        String -> ArgsHMap "log1p(symbol)" args -> IO SymbolHandle
-log1p name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log1p"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log1p(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_log1p ::
-                forall args . Fullfilled "_backward_log1p(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_log1p(symbol)" args -> IO SymbolHandle
-_backward_log1p name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_log1p"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "expm1(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-expm1 ::
-      forall args . Fullfilled "expm1(symbol)" args =>
-        String -> ArgsHMap "expm1(symbol)" args -> IO SymbolHandle
-expm1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expm1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_expm1(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_expm1 ::
-                forall args . Fullfilled "_backward_expm1(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_expm1(symbol)" args -> IO SymbolHandle
-_backward_expm1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_expm1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "gamma(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-gamma ::
-      forall args . Fullfilled "gamma(symbol)" args =>
-        String -> ArgsHMap "gamma(symbol)" args -> IO SymbolHandle
-gamma name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_gamma(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_gamma ::
-                forall args . Fullfilled "_backward_gamma(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_gamma(symbol)" args -> IO SymbolHandle
-_backward_gamma name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gamma"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "gammaln(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-gammaln ::
-        forall args . Fullfilled "gammaln(symbol)" args =>
-          String -> ArgsHMap "gammaln(symbol)" args -> IO SymbolHandle
-gammaln name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gammaln"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_gammaln(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_gammaln ::
-                  forall args . Fullfilled "_backward_gammaln(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_gammaln(symbol)" args -> IO SymbolHandle
-_backward_gammaln name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gammaln"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "logical_not(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-logical_not ::
-            forall args . Fullfilled "logical_not(symbol)" args =>
-              String -> ArgsHMap "logical_not(symbol)" args -> IO SymbolHandle
-logical_not name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "logical_not"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "amp_cast(symbol)" =
-     '[ '("dtype",
-          AttrReq
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("data", AttrOpt SymbolHandle)]
-
-amp_cast ::
-         forall args . Fullfilled "amp_cast(symbol)" args =>
-           String -> ArgsHMap "amp_cast(symbol)" args -> IO SymbolHandle
-amp_cast name args
-  = let scalarArgs
-          = catMaybes
-              [("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "amp_cast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_amp_cast(symbol)" = '[]
-
-_backward_amp_cast ::
-                   forall args . Fullfilled "_backward_amp_cast(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_amp_cast(symbol)" args -> IO SymbolHandle
-_backward_amp_cast name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_amp_cast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "amp_multicast(symbol)" =
-     '[ '("num_outputs", AttrReq Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-amp_multicast ::
-              forall args . Fullfilled "amp_multicast(symbol)" args =>
-                String -> ArgsHMap "amp_multicast(symbol)" args -> IO SymbolHandle
-amp_multicast name args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "amp_multicast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_amp_multicast(symbol)" =
-     '[ '("num_outputs", AttrReq Int),
-        '("grad", AttrOpt [SymbolHandle])]
-
-_backward_amp_multicast ::
-                        forall args . Fullfilled "_backward_amp_multicast(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_amp_multicast(symbol)" args -> IO SymbolHandle
-_backward_amp_multicast name args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #grad :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "_backward_amp_multicast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "elemwise_add(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_add ::
-             forall args . Fullfilled "elemwise_add(symbol)" args =>
-               String -> ArgsHMap "elemwise_add(symbol)" args -> IO SymbolHandle
-elemwise_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_grad_add(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_grad_add ::
-          forall args . Fullfilled "_grad_add(symbol)" args =>
-            String -> ArgsHMap "_grad_add(symbol)" args -> IO SymbolHandle
-_grad_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_grad_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_add(symbol)" = '[]
-
-_backward_add ::
-              forall args . Fullfilled "_backward_add(symbol)" args =>
-                String -> ArgsHMap "_backward_add(symbol)" args -> IO SymbolHandle
-_backward_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_sub(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_sub ::
-             forall args . Fullfilled "elemwise_sub(symbol)" args =>
-               String -> ArgsHMap "elemwise_sub(symbol)" args -> IO SymbolHandle
-elemwise_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sub(symbol)" = '[]
-
-_backward_sub ::
-              forall args . Fullfilled "_backward_sub(symbol)" args =>
-                String -> ArgsHMap "_backward_sub(symbol)" args -> IO SymbolHandle
-_backward_sub name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sub"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_mul(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_mul ::
-             forall args . Fullfilled "elemwise_mul(symbol)" args =>
-               String -> ArgsHMap "elemwise_mul(symbol)" args -> IO SymbolHandle
-elemwise_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mul(symbol)" = '[]
-
-_backward_mul ::
-              forall args . Fullfilled "_backward_mul(symbol)" args =>
-                String -> ArgsHMap "_backward_mul(symbol)" args -> IO SymbolHandle
-_backward_mul name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "elemwise_div(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-elemwise_div ::
-             forall args . Fullfilled "elemwise_div(symbol)" args =>
-               String -> ArgsHMap "elemwise_div(symbol)" args -> IO SymbolHandle
-elemwise_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "elemwise_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_div(symbol)" = '[]
-
-_backward_div ::
-              forall args . Fullfilled "_backward_div(symbol)" args =>
-                String -> ArgsHMap "_backward_div(symbol)" args -> IO SymbolHandle
-_backward_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_mod(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_mod ::
-     forall args . Fullfilled "_mod(symbol)" args =>
-       String -> ArgsHMap "_mod(symbol)" args -> IO SymbolHandle
-_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mod(symbol)" = '[]
-
-_backward_mod ::
-              forall args . Fullfilled "_backward_mod(symbol)" args =>
-                String -> ArgsHMap "_backward_mod(symbol)" args -> IO SymbolHandle
-_backward_mod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_elemwise_div(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_scatter_elemwise_div ::
-                      forall args . Fullfilled "_scatter_elemwise_div(symbol)" args =>
-                        String ->
-                          ArgsHMap "_scatter_elemwise_div(symbol)" args -> IO SymbolHandle
-_scatter_elemwise_div name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_elemwise_div"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_plus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_scatter_plus_scalar ::
-                     forall args . Fullfilled "_scatter_plus_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_scatter_plus_scalar(symbol)" args -> IO SymbolHandle
-_scatter_plus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_plus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_minus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_scatter_minus_scalar ::
-                      forall args . Fullfilled "_scatter_minus_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_scatter_minus_scalar(symbol)" args -> IO SymbolHandle
-_scatter_minus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_minus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Embedding(symbol)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle)]
-
-_Embedding ::
-           forall args . Fullfilled "_Embedding(symbol)" args =>
-             String -> ArgsHMap "_Embedding(symbol)" args -> IO SymbolHandle
-_Embedding name args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Embedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_SparseEmbedding(symbol)" =
-     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle)]
-
-_contrib_SparseEmbedding ::
-                         forall args . Fullfilled "_contrib_SparseEmbedding(symbol)" args =>
-                           String ->
-                             ArgsHMap "_contrib_SparseEmbedding(symbol)" args -> IO SymbolHandle
-_contrib_SparseEmbedding name args
-  = let scalarArgs
-          = catMaybes
-              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"])),
-               ("sparse_grad",) . showValue <$>
-                 (args !? #sparse_grad :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SparseEmbedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Embedding(symbol)" = '[]
-
-_backward_Embedding ::
-                    forall args . Fullfilled "_backward_Embedding(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_Embedding(symbol)" args -> IO SymbolHandle
-_backward_Embedding name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Embedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SparseEmbedding(symbol)" =
-     '[]
-
-_backward_SparseEmbedding ::
-                          forall args .
-                            Fullfilled "_backward_SparseEmbedding(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_SparseEmbedding(symbol)" args ->
-                                IO SymbolHandle
-_backward_SparseEmbedding name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SparseEmbedding"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "take(symbol)" =
-     '[ '("axis", AttrOpt Int),
-        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),
-        '("a", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)]
-
-take ::
-     forall args . Fullfilled "take(symbol)" args =>
-       String -> ArgsHMap "take(symbol)" args -> IO SymbolHandle
-take name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "take"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_take(symbol)" = '[]
-
-_backward_take ::
-               forall args . Fullfilled "_backward_take(symbol)" args =>
-                 String -> ArgsHMap "_backward_take(symbol)" args -> IO SymbolHandle
-_backward_take name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_take"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "batch_take(symbol)" =
-     '[ '("a", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-batch_take ::
-           forall args . Fullfilled "batch_take(symbol)" args =>
-             String -> ArgsHMap "batch_take(symbol)" args -> IO SymbolHandle
-batch_take name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("a",) <$> (args !? #a :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_take"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "one_hot(symbol)" =
-     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),
-        '("off_value", AttrOpt Double),
-        '("dtype",
-          AttrOpt
-            (EnumType
-               '["float16", "float32", "float64", "int32", "int64", "int8",
-                 "uint8"])),
-        '("indices", AttrOpt SymbolHandle)]
-
-one_hot ::
-        forall args . Fullfilled "one_hot(symbol)" args =>
-          String -> ArgsHMap "one_hot(symbol)" args -> IO SymbolHandle
-one_hot name args
-  = let scalarArgs
-          = catMaybes
-              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),
-               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),
-               ("off_value",) . showValue <$>
-                 (args !? #off_value :: Maybe Double),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType
-                         '["float16", "float32", "float64", "int32", "int64", "int8",
-                           "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "one_hot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "gather_nd(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-gather_nd ::
-          forall args . Fullfilled "gather_nd(symbol)" args =>
-            String -> ArgsHMap "gather_nd(symbol)" args -> IO SymbolHandle
-gather_nd name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "gather_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "scatter_nd(symbol)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-scatter_nd ::
-           forall args . Fullfilled "scatter_nd(symbol)" args =>
-             String -> ArgsHMap "scatter_nd(symbol)" args -> IO SymbolHandle
-scatter_nd name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "scatter_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_gather_nd(symbol)" =
-     '[ '("shape", AttrReq [Int]), '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-_backward_gather_nd ::
-                    forall args . Fullfilled "_backward_gather_nd(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_gather_nd(symbol)" args -> IO SymbolHandle
-_backward_gather_nd name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_gather_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_scatter_set_nd(symbol)" =
-     '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle), '("indices", AttrOpt SymbolHandle)]
-
-_scatter_set_nd ::
-                forall args . Fullfilled "_scatter_set_nd(symbol)" args =>
-                  String ->
-                    ArgsHMap "_scatter_set_nd(symbol)" args -> IO SymbolHandle
-_scatter_set_nd name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_scatter_set_nd"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_equal ::
-                forall args . Fullfilled "broadcast_equal(symbol)" args =>
-                  String ->
-                    ArgsHMap "broadcast_equal(symbol)" args -> IO SymbolHandle
-broadcast_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_not_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_not_equal ::
-                    forall args . Fullfilled "broadcast_not_equal(symbol)" args =>
-                      String ->
-                        ArgsHMap "broadcast_not_equal(symbol)" args -> IO SymbolHandle
-broadcast_not_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_not_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_greater(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_greater ::
-                  forall args . Fullfilled "broadcast_greater(symbol)" args =>
-                    String ->
-                      ArgsHMap "broadcast_greater(symbol)" args -> IO SymbolHandle
-broadcast_greater name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_greater_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_greater_equal ::
-                        forall args . Fullfilled "broadcast_greater_equal(symbol)" args =>
-                          String ->
-                            ArgsHMap "broadcast_greater_equal(symbol)" args -> IO SymbolHandle
-broadcast_greater_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_greater_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_lesser(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_lesser ::
-                 forall args . Fullfilled "broadcast_lesser(symbol)" args =>
-                   String ->
-                     ArgsHMap "broadcast_lesser(symbol)" args -> IO SymbolHandle
-broadcast_lesser name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_lesser_equal(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_lesser_equal ::
-                       forall args . Fullfilled "broadcast_lesser_equal(symbol)" args =>
-                         String ->
-                           ArgsHMap "broadcast_lesser_equal(symbol)" args -> IO SymbolHandle
-broadcast_lesser_equal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_lesser_equal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_logical_and(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_logical_and ::
-                      forall args . Fullfilled "broadcast_logical_and(symbol)" args =>
-                        String ->
-                          ArgsHMap "broadcast_logical_and(symbol)" args -> IO SymbolHandle
-broadcast_logical_and name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_and"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_logical_or(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_logical_or ::
-                     forall args . Fullfilled "broadcast_logical_or(symbol)" args =>
-                       String ->
-                         ArgsHMap "broadcast_logical_or(symbol)" args -> IO SymbolHandle
-broadcast_logical_or name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_or"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_logical_xor(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_logical_xor ::
-                      forall args . Fullfilled "broadcast_logical_xor(symbol)" args =>
-                        String ->
-                          ArgsHMap "broadcast_logical_xor(symbol)" args -> IO SymbolHandle
-broadcast_logical_xor name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_logical_xor"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_plus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_plus_scalar ::
-             forall args . Fullfilled "_plus_scalar(symbol)" args =>
-               String -> ArgsHMap "_plus_scalar(symbol)" args -> IO SymbolHandle
-_plus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_plus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_minus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_minus_scalar ::
-              forall args . Fullfilled "_minus_scalar(symbol)" args =>
-                String -> ArgsHMap "_minus_scalar(symbol)" args -> IO SymbolHandle
-_minus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rminus_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rminus_scalar ::
-               forall args . Fullfilled "_rminus_scalar(symbol)" args =>
-                 String -> ArgsHMap "_rminus_scalar(symbol)" args -> IO SymbolHandle
-_rminus_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rminus_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_mul_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_mul_scalar ::
-            forall args . Fullfilled "_mul_scalar(symbol)" args =>
-              String -> ArgsHMap "_mul_scalar(symbol)" args -> IO SymbolHandle
-_mul_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mul_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mul_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_backward_mul_scalar ::
-                     forall args . Fullfilled "_backward_mul_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_mul_scalar(symbol)" args -> IO SymbolHandle
-_backward_mul_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mul_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_div_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_div_scalar ::
-            forall args . Fullfilled "_div_scalar(symbol)" args =>
-              String -> ArgsHMap "_div_scalar(symbol)" args -> IO SymbolHandle
-_div_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_div_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_div_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_backward_div_scalar ::
-                     forall args . Fullfilled "_backward_div_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_div_scalar(symbol)" args -> IO SymbolHandle
-_backward_div_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_div_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rdiv_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rdiv_scalar ::
-             forall args . Fullfilled "_rdiv_scalar(symbol)" args =>
-               String -> ArgsHMap "_rdiv_scalar(symbol)" args -> IO SymbolHandle
-_rdiv_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rdiv_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rdiv_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rdiv_scalar ::
-                      forall args . Fullfilled "_backward_rdiv_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_rdiv_scalar(symbol)" args -> IO SymbolHandle
-_backward_rdiv_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rdiv_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_mod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_mod_scalar ::
-            forall args . Fullfilled "_mod_scalar(symbol)" args =>
-              String -> ArgsHMap "_mod_scalar(symbol)" args -> IO SymbolHandle
-_mod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_mod_scalar ::
-                     forall args . Fullfilled "_backward_mod_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_mod_scalar(symbol)" args -> IO SymbolHandle
-_backward_mod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rmod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rmod_scalar ::
-             forall args . Fullfilled "_rmod_scalar(symbol)" args =>
-               String -> ArgsHMap "_rmod_scalar(symbol)" args -> IO SymbolHandle
-_rmod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rmod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rmod_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rmod_scalar ::
-                      forall args . Fullfilled "_backward_rmod_scalar(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_rmod_scalar(symbol)" args -> IO SymbolHandle
-_backward_rmod_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rmod_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_ravel_multi_index(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-_ravel_multi_index ::
-                   forall args . Fullfilled "_ravel_multi_index(symbol)" args =>
-                     String ->
-                       ArgsHMap "_ravel_multi_index(symbol)" args -> IO SymbolHandle
-_ravel_multi_index name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_ravel_multi_index"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_unravel_index(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-_unravel_index ::
-               forall args . Fullfilled "_unravel_index(symbol)" args =>
-                 String -> ArgsHMap "_unravel_index(symbol)" args -> IO SymbolHandle
-_unravel_index name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_unravel_index"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sum(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-sum ::
-    forall args . Fullfilled "sum(symbol)" args =>
-      String -> ArgsHMap "sum(symbol)" args -> IO SymbolHandle
-sum name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sum(symbol)" = '[]
-
-_backward_sum ::
-              forall args . Fullfilled "_backward_sum(symbol)" args =>
-                String -> ArgsHMap "_backward_sum(symbol)" args -> IO SymbolHandle
-_backward_sum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "mean(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-mean ::
-     forall args . Fullfilled "mean(symbol)" args =>
-       String -> ArgsHMap "mean(symbol)" args -> IO SymbolHandle
-mean name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mean"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mean(symbol)" = '[]
-
-_backward_mean ::
-               forall args . Fullfilled "_backward_mean(symbol)" args =>
-                 String -> ArgsHMap "_backward_mean(symbol)" args -> IO SymbolHandle
-_backward_mean name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mean"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "prod(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-prod ::
-     forall args . Fullfilled "prod(symbol)" args =>
-       String -> ArgsHMap "prod(symbol)" args -> IO SymbolHandle
-prod name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "prod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_prod(symbol)" = '[]
-
-_backward_prod ::
-               forall args . Fullfilled "_backward_prod(symbol)" args =>
-                 String -> ArgsHMap "_backward_prod(symbol)" args -> IO SymbolHandle
-_backward_prod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_prod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "nansum(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-nansum ::
-       forall args . Fullfilled "nansum(symbol)" args =>
-         String -> ArgsHMap "nansum(symbol)" args -> IO SymbolHandle
-nansum name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nansum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_nansum(symbol)" = '[]
-
-_backward_nansum ::
-                 forall args . Fullfilled "_backward_nansum(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_nansum(symbol)" args -> IO SymbolHandle
-_backward_nansum name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nansum"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "nanprod(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-nanprod ::
-        forall args . Fullfilled "nanprod(symbol)" args =>
-          String -> ArgsHMap "nanprod(symbol)" args -> IO SymbolHandle
-nanprod name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nanprod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_nanprod(symbol)" = '[]
-
-_backward_nanprod ::
-                  forall args . Fullfilled "_backward_nanprod(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_nanprod(symbol)" args -> IO SymbolHandle
-_backward_nanprod name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_nanprod"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "max(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-max ::
-    forall args . Fullfilled "max(symbol)" args =>
-      String -> ArgsHMap "max(symbol)" args -> IO SymbolHandle
-max name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "max"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_max(symbol)" = '[]
-
-_backward_max ::
-              forall args . Fullfilled "_backward_max(symbol)" args =>
-                String -> ArgsHMap "_backward_max(symbol)" args -> IO SymbolHandle
-_backward_max name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_max"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "min(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("exclude", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-min ::
-    forall args . Fullfilled "min(symbol)" args =>
-      String -> ArgsHMap "min(symbol)" args -> IO SymbolHandle
-min name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "min"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_min(symbol)" = '[]
-
-_backward_min ::
-              forall args . Fullfilled "_backward_min(symbol)" args =>
-                String -> ArgsHMap "_backward_min(symbol)" args -> IO SymbolHandle
-_backward_min name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_min"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_axis(symbol)" =
-     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-broadcast_axis ::
-               forall args . Fullfilled "broadcast_axis(symbol)" args =>
-                 String -> ArgsHMap "broadcast_axis(symbol)" args -> IO SymbolHandle
-broadcast_axis name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
-               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_axis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_to(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-broadcast_to ::
-             forall args . Fullfilled "broadcast_to(symbol)" args =>
-               String -> ArgsHMap "broadcast_to(symbol)" args -> IO SymbolHandle
-broadcast_to name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_to"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_broadcast_backward(symbol)" = '[]
-
-_broadcast_backward ::
-                    forall args . Fullfilled "_broadcast_backward(symbol)" args =>
-                      String ->
-                        ArgsHMap "_broadcast_backward(symbol)" args -> IO SymbolHandle
-_broadcast_backward name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_broadcast_backward"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "broadcast_like(symbol)" =
-     '[ '("lhs_axes", AttrOpt (Maybe [Int])),
-        '("rhs_axes", AttrOpt (Maybe [Int])),
-        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-broadcast_like ::
-               forall args . Fullfilled "broadcast_like(symbol)" args =>
-                 String -> ArgsHMap "broadcast_like(symbol)" args -> IO SymbolHandle
-broadcast_like name args
-  = let scalarArgs
-          = catMaybes
-              [("lhs_axes",) . showValue <$>
-                 (args !? #lhs_axes :: Maybe (Maybe [Int])),
-               ("rhs_axes",) . showValue <$>
-                 (args !? #rhs_axes :: Maybe (Maybe [Int]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "broadcast_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "norm(symbol)" =
-     '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])),
-        '("out_dtype",
-          AttrOpt
-            (Maybe
-               (EnumType
-                  '["float16", "float32", "float64", "int32", "int64", "int8"]))),
-        '("keepdims", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-norm ::
-     forall args . Fullfilled "norm(symbol)" args =>
-       String -> ArgsHMap "norm(symbol)" args -> IO SymbolHandle
-norm name args
-  = let scalarArgs
-          = catMaybes
-              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
-               ("out_dtype",) . showValue <$>
-                 (args !? #out_dtype ::
-                    Maybe
-                      (Maybe
-                         (EnumType
-                            '["float16", "float32", "float64", "int32", "int64", "int8"]))),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "norm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_norm(symbol)" = '[]
-
-_backward_norm ::
-               forall args . Fullfilled "_backward_norm(symbol)" args =>
-                 String -> ArgsHMap "_backward_norm(symbol)" args -> IO SymbolHandle
-_backward_norm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_norm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argmax(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-argmax ::
-       forall args . Fullfilled "argmax(symbol)" args =>
-         String -> ArgsHMap "argmax(symbol)" args -> IO SymbolHandle
-argmax name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argmin(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-argmin ::
-       forall args . Fullfilled "argmin(symbol)" args =>
-         String -> ArgsHMap "argmin(symbol)" args -> IO SymbolHandle
-argmin name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argmax_channel(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-argmax_channel ::
-               forall args . Fullfilled "argmax_channel(symbol)" args =>
-                 String -> ArgsHMap "argmax_channel(symbol)" args -> IO SymbolHandle
-argmax_channel name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argmax_channel"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "pick(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
-        '("mode", AttrOpt (EnumType '["clip", "wrap"])),
-        '("data", AttrOpt SymbolHandle), '("index", AttrOpt SymbolHandle)]
-
-pick ::
-     forall args . Fullfilled "pick(symbol)" args =>
-       String -> ArgsHMap "pick(symbol)" args -> IO SymbolHandle
-pick name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("index",) <$> (args !? #index :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "pick"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_pick(symbol)" = '[]
-
-_backward_pick ::
-               forall args . Fullfilled "_backward_pick(symbol)" args =>
-                 String -> ArgsHMap "_backward_pick(symbol)" args -> IO SymbolHandle
-_backward_pick name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_pick"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sparse_retain(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("indices", AttrOpt SymbolHandle)]
-
-_sparse_retain ::
-               forall args . Fullfilled "_sparse_retain(symbol)" args =>
-                 String -> ArgsHMap "_sparse_retain(symbol)" args -> IO SymbolHandle
-_sparse_retain name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("indices",) <$> (args !? #indices :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_retain"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sparse_retain(symbol)" = '[]
-
-_backward_sparse_retain ::
-                        forall args . Fullfilled "_backward_sparse_retain(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_sparse_retain(symbol)" args -> IO SymbolHandle
-_backward_sparse_retain name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sparse_retain"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_where(symbol)" =
-     '[ '("condition", AttrOpt SymbolHandle),
-        '("x", AttrOpt SymbolHandle), '("y", AttrOpt SymbolHandle)]
-
-_where ::
-       forall args . Fullfilled "_where(symbol)" args =>
-         String -> ArgsHMap "_where(symbol)" args -> IO SymbolHandle
-_where name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("condition",) <$> (args !? #condition :: Maybe SymbolHandle),
-               ("x",) <$> (args !? #x :: Maybe SymbolHandle),
-               ("y",) <$> (args !? #y :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "where"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_where(symbol)" = '[]
-
-_backward_where ::
-                forall args . Fullfilled "_backward_where(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_where(symbol)" args -> IO SymbolHandle
-_backward_where name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_where"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "diag(symbol)" =
-     '[ '("k", AttrOpt Int), '("axis1", AttrOpt Int),
-        '("axis2", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-diag ::
-     forall args . Fullfilled "diag(symbol)" args =>
-       String -> ArgsHMap "diag(symbol)" args -> IO SymbolHandle
-diag name args
-  = let scalarArgs
-          = catMaybes
-              [("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int),
-               ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "diag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_diag(symbol)" = '[]
-
-_backward_diag ::
-               forall args . Fullfilled "_backward_diag(symbol)" args =>
-                 String -> ArgsHMap "_backward_diag(symbol)" args -> IO SymbolHandle
-_backward_diag name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_diag"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_maximum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_maximum_scalar ::
-                forall args . Fullfilled "_maximum_scalar(symbol)" args =>
-                  String ->
-                    ArgsHMap "_maximum_scalar(symbol)" args -> IO SymbolHandle
-_maximum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_maximum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_maximum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_maximum_scalar ::
-                         forall args . Fullfilled "_backward_maximum_scalar(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_maximum_scalar(symbol)" args -> IO SymbolHandle
-_backward_maximum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_maximum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_minimum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_minimum_scalar ::
-                forall args . Fullfilled "_minimum_scalar(symbol)" args =>
-                  String ->
-                    ArgsHMap "_minimum_scalar(symbol)" args -> IO SymbolHandle
-_minimum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_minimum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_minimum_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_minimum_scalar ::
-                         forall args . Fullfilled "_backward_minimum_scalar(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_minimum_scalar(symbol)" args -> IO SymbolHandle
-_backward_minimum_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_minimum_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_power_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_power_scalar ::
-              forall args . Fullfilled "_power_scalar(symbol)" args =>
-                String -> ArgsHMap "_power_scalar(symbol)" args -> IO SymbolHandle
-_power_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_power_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_power_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_power_scalar ::
-                       forall args . Fullfilled "_backward_power_scalar(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_power_scalar(symbol)" args -> IO SymbolHandle
-_backward_power_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_power_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rpower_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_rpower_scalar ::
-               forall args . Fullfilled "_rpower_scalar(symbol)" args =>
-                 String -> ArgsHMap "_rpower_scalar(symbol)" args -> IO SymbolHandle
-_rpower_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_rpower_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_rpower_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_rpower_scalar ::
-                        forall args . Fullfilled "_backward_rpower_scalar(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_rpower_scalar(symbol)" args -> IO SymbolHandle
-_backward_rpower_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_rpower_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_hypot_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_hypot_scalar ::
-              forall args . Fullfilled "_hypot_scalar(symbol)" args =>
-                String -> ArgsHMap "_hypot_scalar(symbol)" args -> IO SymbolHandle
-_hypot_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_hypot_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_hypot_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_backward_hypot_scalar ::
-                       forall args . Fullfilled "_backward_hypot_scalar(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_hypot_scalar(symbol)" args -> IO SymbolHandle
-_backward_hypot_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_hypot_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "smooth_l1(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-smooth_l1 ::
-          forall args . Fullfilled "smooth_l1(symbol)" args =>
-            String -> ArgsHMap "smooth_l1(symbol)" args -> IO SymbolHandle
-smooth_l1 name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "smooth_l1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_smooth_l1(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_smooth_l1 ::
-                    forall args . Fullfilled "_backward_smooth_l1(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_smooth_l1(symbol)" args -> IO SymbolHandle
-_backward_smooth_l1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_smooth_l1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "topk(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),
-        '("ret_typ",
-          AttrOpt (EnumType '["both", "indices", "mask", "value"])),
-        '("is_ascend", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt SymbolHandle)]
-
-topk ::
-     forall args . Fullfilled "topk(symbol)" args =>
-       String -> ArgsHMap "topk(symbol)" args -> IO SymbolHandle
-topk name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("k",) . showValue <$> (args !? #k :: Maybe Int),
-               ("ret_typ",) . showValue <$>
-                 (args !? #ret_typ ::
-                    Maybe (EnumType '["both", "indices", "mask", "value"])),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "topk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_topk(symbol)" = '[]
-
-_backward_topk ::
-               forall args . Fullfilled "_backward_topk(symbol)" args =>
-                 String -> ArgsHMap "_backward_topk(symbol)" args -> IO SymbolHandle
-_backward_topk name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_topk"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sort(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-sort ::
-     forall args . Fullfilled "sort(symbol)" args =>
-       String -> ArgsHMap "sort(symbol)" args -> IO SymbolHandle
-sort name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sort"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "argsort(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
-        '("dtype",
-          AttrOpt
-            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
-        '("data", AttrOpt SymbolHandle)]
-
-argsort ::
-        forall args . Fullfilled "argsort(symbol)" args =>
-          String -> ArgsHMap "argsort(symbol)" args -> IO SymbolHandle
-argsort name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
-               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe
-                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "argsort"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Reshape(symbol)" =
-     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),
-        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-_Reshape ::
-         forall args . Fullfilled "_Reshape(symbol)" args =>
-           String -> ArgsHMap "_Reshape(symbol)" args -> IO SymbolHandle
-_Reshape name args
-  = let scalarArgs
-          = catMaybes
-              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
-               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("keep_highest",) . showValue <$>
-                 (args !? #keep_highest :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Reshape"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Flatten(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_Flatten ::
-         forall args . Fullfilled "_Flatten(symbol)" args =>
-           String -> ArgsHMap "_Flatten(symbol)" args -> IO SymbolHandle
-_Flatten name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Flatten"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "transpose(symbol)" =
-     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-transpose ::
-          forall args . Fullfilled "transpose(symbol)" args =>
-            String -> ArgsHMap "transpose(symbol)" args -> IO SymbolHandle
-transpose name args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "transpose"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "expand_dims(symbol)" =
-     '[ '("axis", AttrReq Int), '("data", AttrOpt SymbolHandle)]
-
-expand_dims ::
-            forall args . Fullfilled "expand_dims(symbol)" args =>
-              String -> ArgsHMap "expand_dims(symbol)" args -> IO SymbolHandle
-expand_dims name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "expand_dims"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "slice(symbol)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-slice ::
-      forall args . Fullfilled "slice(symbol)" args =>
-        String -> ArgsHMap "slice(symbol)" args -> IO SymbolHandle
-slice name args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_slice(symbol)" = '[]
-
-_backward_slice ::
-                forall args . Fullfilled "_backward_slice(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_slice(symbol)" args -> IO SymbolHandle
-_backward_slice name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_slice_assign(symbol)" =
-     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
-        '("step", AttrOpt [Int]), '("lhs", AttrOpt SymbolHandle),
-        '("rhs", AttrOpt SymbolHandle)]
-
-_slice_assign ::
-              forall args . Fullfilled "_slice_assign(symbol)" args =>
-                String -> ArgsHMap "_slice_assign(symbol)" args -> IO SymbolHandle
-_slice_assign name args
-  = let scalarArgs
-          = catMaybes
-              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_slice_assign_scalar(symbol)" =
-     '[ '("scalar", AttrOpt Double), '("begin", AttrReq [Int]),
-        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-_slice_assign_scalar ::
-                     forall args . Fullfilled "_slice_assign_scalar(symbol)" args =>
-                       String ->
-                         ArgsHMap "_slice_assign_scalar(symbol)" args -> IO SymbolHandle
-_slice_assign_scalar name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
-               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
-               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_slice_assign_scalar"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "slice_axis(symbol)" =
-     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),
-        '("end", AttrReq (Maybe Int)), '("data", AttrOpt SymbolHandle)]
-
-slice_axis ::
-           forall args . Fullfilled "slice_axis(symbol)" args =>
-             String -> ArgsHMap "slice_axis(symbol)" args -> IO SymbolHandle
-slice_axis name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),
-               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_axis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_slice_axis(symbol)" = '[]
-
-_backward_slice_axis ::
-                     forall args . Fullfilled "_backward_slice_axis(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_slice_axis(symbol)" args -> IO SymbolHandle
-_backward_slice_axis name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_axis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "slice_like(symbol)" =
-     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt SymbolHandle),
-        '("shape_like", AttrOpt SymbolHandle)]
-
-slice_like ::
-           forall args . Fullfilled "slice_like(symbol)" args =>
-             String -> ArgsHMap "slice_like(symbol)" args -> IO SymbolHandle
-slice_like name args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("shape_like",) <$> (args !? #shape_like :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "slice_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_slice_like(symbol)" = '[]
-
-_backward_slice_like ::
-                     forall args . Fullfilled "_backward_slice_like(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_slice_like(symbol)" args -> IO SymbolHandle
-_backward_slice_like name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_slice_like"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "clip(symbol)" =
-     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-clip ::
-     forall args . Fullfilled "clip(symbol)" args =>
-       String -> ArgsHMap "clip(symbol)" args -> IO SymbolHandle
-clip name args
-  = let scalarArgs
-          = catMaybes
-              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),
-               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "clip"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_clip(symbol)" = '[]
-
-_backward_clip ::
-               forall args . Fullfilled "_backward_clip(symbol)" args =>
-                 String -> ArgsHMap "_backward_clip(symbol)" args -> IO SymbolHandle
-_backward_clip name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_clip"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "repeat(symbol)" =
-     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),
-        '("data", AttrOpt SymbolHandle)]
-
-repeat ::
-       forall args . Fullfilled "repeat(symbol)" args =>
-         String -> ArgsHMap "repeat(symbol)" args -> IO SymbolHandle
-repeat name args
-  = let scalarArgs
-          = catMaybes
-              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "repeat"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_repeat(symbol)" = '[]
-
-_backward_repeat ::
-                 forall args . Fullfilled "_backward_repeat(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_repeat(symbol)" args -> IO SymbolHandle
-_backward_repeat name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_repeat"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "tile(symbol)" =
-     '[ '("reps", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]
-
-tile ::
-     forall args . Fullfilled "tile(symbol)" args =>
-       String -> ArgsHMap "tile(symbol)" args -> IO SymbolHandle
-tile name args
-  = let scalarArgs
-          = catMaybes
-              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tile"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_tile(symbol)" = '[]
-
-_backward_tile ::
-               forall args . Fullfilled "_backward_tile(symbol)" args =>
-                 String -> ArgsHMap "_backward_tile(symbol)" args -> IO SymbolHandle
-_backward_tile name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tile"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "reverse(symbol)" =
-     '[ '("axis", AttrReq [Int]), '("data", AttrOpt SymbolHandle)]
-
-reverse ::
-        forall args . Fullfilled "reverse(symbol)" args =>
-          String -> ArgsHMap "reverse(symbol)" args -> IO SymbolHandle
-reverse name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "reverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_reverse(symbol)" = '[]
-
-_backward_reverse ::
-                  forall args . Fullfilled "_backward_reverse(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_reverse(symbol)" args -> IO SymbolHandle
-_backward_reverse name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_reverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "stack(symbol)" =
-     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-stack ::
-      forall args . Fullfilled "stack(symbol)" args =>
-        String -> ArgsHMap "stack(symbol)" args -> IO SymbolHandle
-stack name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "stack"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_stack(symbol)" = '[]
-
-_backward_stack ::
-                forall args . Fullfilled "_backward_stack(symbol)" args =>
-                  String ->
-                    ArgsHMap "_backward_stack(symbol)" args -> IO SymbolHandle
-_backward_stack name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_stack"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "squeeze(symbol)" =
-     '[ '("axis", AttrOpt (Maybe [Int])),
-        '("data", AttrOpt [SymbolHandle])]
-
-squeeze ::
-        forall args . Fullfilled "squeeze(symbol)" args =>
-          String -> ArgsHMap "squeeze(symbol)" args -> IO SymbolHandle
-squeeze name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "squeeze"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_squeeze(symbol)" = '[]
-
-_backward_squeeze ::
-                  forall args . Fullfilled "_backward_squeeze(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_squeeze(symbol)" args -> IO SymbolHandle
-_backward_squeeze name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_squeeze"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "depth_to_space(symbol)" =
-     '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)]
-
-depth_to_space ::
-               forall args . Fullfilled "depth_to_space(symbol)" args =>
-                 String -> ArgsHMap "depth_to_space(symbol)" args -> IO SymbolHandle
-depth_to_space name args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "depth_to_space"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "space_to_depth(symbol)" =
-     '[ '("block_size", AttrReq Int), '("data", AttrOpt SymbolHandle)]
-
-space_to_depth ::
-               forall args . Fullfilled "space_to_depth(symbol)" args =>
-                 String -> ArgsHMap "space_to_depth(symbol)" args -> IO SymbolHandle
-space_to_depth name args
-  = let scalarArgs
-          = catMaybes
-              [("block_size",) . showValue <$>
-                 (args !? #block_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "space_to_depth"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_split_v2(symbol)" =
-     '[ '("indices", AttrReq [Int]), '("axis", AttrOpt Int),
-        '("squeeze_axis", AttrOpt Bool), '("sections", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle)]
-
-_split_v2 ::
-          forall args . Fullfilled "_split_v2(symbol)" args =>
-            String -> ArgsHMap "_split_v2(symbol)" args -> IO SymbolHandle
-_split_v2 name args
-  = let scalarArgs
-          = catMaybes
-              [("indices",) . showValue <$> (args !? #indices :: Maybe [Int]),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool),
-               ("sections",) . showValue <$> (args !? #sections :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_split_v2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_split_v2_backward(symbol)" = '[]
-
-_split_v2_backward ::
-                   forall args . Fullfilled "_split_v2_backward(symbol)" args =>
-                     String ->
-                       ArgsHMap "_split_v2_backward(symbol)" args -> IO SymbolHandle
-_split_v2_backward name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_split_v2_backward"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "dot(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),
-        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-dot ::
-    forall args . Fullfilled "dot(symbol)" args =>
-      String -> ArgsHMap "dot(symbol)" args -> IO SymbolHandle
-dot name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_dot(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-
-_backward_dot ::
-              forall args . Fullfilled "_backward_dot(symbol)" args =>
-                String -> ArgsHMap "_backward_dot(symbol)" args -> IO SymbolHandle
-_backward_dot name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "batch_dot(symbol)" =
-     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
-        '("forward_stype",
-          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),
-        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-batch_dot ::
-          forall args . Fullfilled "batch_dot(symbol)" args =>
-            String -> ArgsHMap "batch_dot(symbol)" args -> IO SymbolHandle
-batch_dot name args
-  = let scalarArgs
-          = catMaybes
-              [("transpose_a",) . showValue <$>
-                 (args !? #transpose_a :: Maybe Bool),
-               ("transpose_b",) . showValue <$>
-                 (args !? #transpose_b :: Maybe Bool),
-               ("forward_stype",) . showValue <$>
-                 (args !? #forward_stype ::
-                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "batch_dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_batch_dot(symbol)" = '[]
-
-_backward_batch_dot ::
-                    forall args . Fullfilled "_backward_batch_dot(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_batch_dot(symbol)" args -> IO SymbolHandle
-_backward_batch_dot name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_batch_dot"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sin(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sin ::
-    forall args . Fullfilled "sin(symbol)" args =>
-      String -> ArgsHMap "sin(symbol)" args -> IO SymbolHandle
-sin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sin(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sin ::
-              forall args . Fullfilled "_backward_sin(symbol)" args =>
-                String -> ArgsHMap "_backward_sin(symbol)" args -> IO SymbolHandle
-_backward_sin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cos(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-cos ::
-    forall args . Fullfilled "cos(symbol)" args =>
-      String -> ArgsHMap "cos(symbol)" args -> IO SymbolHandle
-cos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cos(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_cos ::
-              forall args . Fullfilled "_backward_cos(symbol)" args =>
-                String -> ArgsHMap "_backward_cos(symbol)" args -> IO SymbolHandle
-_backward_cos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "tan(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-tan ::
-    forall args . Fullfilled "tan(symbol)" args =>
-      String -> ArgsHMap "tan(symbol)" args -> IO SymbolHandle
-tan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_tan(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_tan ::
-              forall args . Fullfilled "_backward_tan(symbol)" args =>
-                String -> ArgsHMap "_backward_tan(symbol)" args -> IO SymbolHandle
-_backward_tan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arcsin(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arcsin ::
-       forall args . Fullfilled "arcsin(symbol)" args =>
-         String -> ArgsHMap "arcsin(symbol)" args -> IO SymbolHandle
-arcsin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arcsin(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arcsin ::
-                 forall args . Fullfilled "_backward_arcsin(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_arcsin(symbol)" args -> IO SymbolHandle
-_backward_arcsin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arccos(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arccos ::
-       forall args . Fullfilled "arccos(symbol)" args =>
-         String -> ArgsHMap "arccos(symbol)" args -> IO SymbolHandle
-arccos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arccos(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arccos ::
-                 forall args . Fullfilled "_backward_arccos(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_arccos(symbol)" args -> IO SymbolHandle
-_backward_arccos name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccos"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arctan(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arctan ::
-       forall args . Fullfilled "arctan(symbol)" args =>
-         String -> ArgsHMap "arctan(symbol)" args -> IO SymbolHandle
-arctan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arctan(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arctan ::
-                 forall args . Fullfilled "_backward_arctan(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_arctan(symbol)" args -> IO SymbolHandle
-_backward_arctan name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctan"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "degrees(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-degrees ::
-        forall args . Fullfilled "degrees(symbol)" args =>
-          String -> ArgsHMap "degrees(symbol)" args -> IO SymbolHandle
-degrees name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "degrees"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_degrees(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_degrees ::
-                  forall args . Fullfilled "_backward_degrees(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_degrees(symbol)" args -> IO SymbolHandle
-_backward_degrees name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_degrees"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "radians(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-radians ::
-        forall args . Fullfilled "radians(symbol)" args =>
-          String -> ArgsHMap "radians(symbol)" args -> IO SymbolHandle
-radians name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "radians"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_radians(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_radians ::
-                  forall args . Fullfilled "_backward_radians(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_radians(symbol)" args -> IO SymbolHandle
-_backward_radians name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_radians"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sinh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-sinh ::
-     forall args . Fullfilled "sinh(symbol)" args =>
-       String -> ArgsHMap "sinh(symbol)" args -> IO SymbolHandle
-sinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_sinh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_sinh ::
-               forall args . Fullfilled "_backward_sinh(symbol)" args =>
-                 String -> ArgsHMap "_backward_sinh(symbol)" args -> IO SymbolHandle
-_backward_sinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_sinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "cosh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-cosh ::
-     forall args . Fullfilled "cosh(symbol)" args =>
-       String -> ArgsHMap "cosh(symbol)" args -> IO SymbolHandle
-cosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "cosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cosh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_cosh ::
-               forall args . Fullfilled "_backward_cosh(symbol)" args =>
-                 String -> ArgsHMap "_backward_cosh(symbol)" args -> IO SymbolHandle
-_backward_cosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "tanh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-tanh ::
-     forall args . Fullfilled "tanh(symbol)" args =>
-       String -> ArgsHMap "tanh(symbol)" args -> IO SymbolHandle
-tanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "tanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_tanh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_tanh ::
-               forall args . Fullfilled "_backward_tanh(symbol)" args =>
-                 String -> ArgsHMap "_backward_tanh(symbol)" args -> IO SymbolHandle
-_backward_tanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_tanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arcsinh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arcsinh ::
-        forall args . Fullfilled "arcsinh(symbol)" args =>
-          String -> ArgsHMap "arcsinh(symbol)" args -> IO SymbolHandle
-arcsinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arcsinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arcsinh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arcsinh ::
-                  forall args . Fullfilled "_backward_arcsinh(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_arcsinh(symbol)" args -> IO SymbolHandle
-_backward_arcsinh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arcsinh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arccosh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arccosh ::
-        forall args . Fullfilled "arccosh(symbol)" args =>
-          String -> ArgsHMap "arccosh(symbol)" args -> IO SymbolHandle
-arccosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arccosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arccosh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arccosh ::
-                  forall args . Fullfilled "_backward_arccosh(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_arccosh(symbol)" args -> IO SymbolHandle
-_backward_arccosh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arccosh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "arctanh(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-arctanh ::
-        forall args . Fullfilled "arctanh(symbol)" args =>
-          String -> ArgsHMap "arctanh(symbol)" args -> IO SymbolHandle
-arctanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "arctanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_arctanh(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_backward_arctanh ::
-                  forall args . Fullfilled "_backward_arctanh(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_arctanh(symbol)" args -> IO SymbolHandle
-_backward_arctanh name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_arctanh"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "khatri_rao(symbol)" =
-     '[ '("args", AttrOpt [SymbolHandle])]
-
-khatri_rao ::
-           forall args . Fullfilled "khatri_rao(symbol)" args =>
-             String -> ArgsHMap "khatri_rao(symbol)" args -> IO SymbolHandle
-khatri_rao name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "khatri_rao"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_contrib_group_adagrad_update(symbol)"
-     =
-     '[ '("lr", AttrReq Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("history", AttrOpt SymbolHandle)]
-
-_contrib_group_adagrad_update ::
-                              forall args .
-                                Fullfilled "_contrib_group_adagrad_update(symbol)" args =>
-                                String ->
-                                  ArgsHMap "_contrib_group_adagrad_update(symbol)" args ->
-                                    IO SymbolHandle
-_contrib_group_adagrad_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("history",) <$> (args !? #history :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_group_adagrad_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_getnnz(symbol)" =
-     '[ '("axis", AttrOpt (Maybe Int)), '("data", AttrOpt SymbolHandle)]
-
-_contrib_getnnz ::
-                forall args . Fullfilled "_contrib_getnnz(symbol)" args =>
-                  String ->
-                    ArgsHMap "_contrib_getnnz(symbol)" args -> IO SymbolHandle
-_contrib_getnnz name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_getnnz"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_gradientmultiplier(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_contrib_gradientmultiplier ::
-                            forall args .
-                              Fullfilled "_contrib_gradientmultiplier(symbol)" args =>
-                              String ->
-                                ArgsHMap "_contrib_gradientmultiplier(symbol)" args ->
-                                  IO SymbolHandle
-_contrib_gradientmultiplier name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_gradientmultiplier"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_contrib_backward_gradientmultiplier(symbol)" =
-     '[ '("scalar", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_contrib_backward_gradientmultiplier ::
-                                     forall args .
-                                       Fullfilled "_contrib_backward_gradientmultiplier(symbol)"
-                                         args =>
-                                       String ->
-                                         ArgsHMap "_contrib_backward_gradientmultiplier(symbol)"
-                                           args
-                                           -> IO SymbolHandle
-_contrib_backward_gradientmultiplier name args
-  = let scalarArgs
-          = catMaybes
-              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_gradientmultiplier"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_edge_id(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle), '("u", AttrOpt SymbolHandle),
-        '("v", AttrOpt SymbolHandle)]
-
-_contrib_edge_id ::
-                 forall args . Fullfilled "_contrib_edge_id(symbol)" args =>
-                   String ->
-                     ArgsHMap "_contrib_edge_id(symbol)" args -> IO SymbolHandle
-_contrib_edge_id name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("u",) <$> (args !? #u :: Maybe SymbolHandle),
-               ("v",) <$> (args !? #v :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_edge_id"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_dgl_adjacency(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_contrib_dgl_adjacency ::
-                       forall args . Fullfilled "_contrib_dgl_adjacency(symbol)" args =>
-                         String ->
-                           ArgsHMap "_contrib_dgl_adjacency(symbol)" args -> IO SymbolHandle
-_contrib_dgl_adjacency name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dgl_adjacency"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_hawkesll(symbol)" =
-     '[ '("lda", AttrOpt SymbolHandle),
-        '("alpha", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),
-        '("state", AttrOpt SymbolHandle), '("lags", AttrOpt SymbolHandle),
-        '("marks", AttrOpt SymbolHandle),
-        '("valid_length", AttrOpt SymbolHandle),
-        '("max_time", AttrOpt SymbolHandle)]
-
-_contrib_hawkesll ::
-                  forall args . Fullfilled "_contrib_hawkesll(symbol)" args =>
-                    String ->
-                      ArgsHMap "_contrib_hawkesll(symbol)" args -> IO SymbolHandle
-_contrib_hawkesll name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lda",) <$> (args !? #lda :: Maybe SymbolHandle),
-               ("alpha",) <$> (args !? #alpha :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),
-               ("state",) <$> (args !? #state :: Maybe SymbolHandle),
-               ("lags",) <$> (args !? #lags :: Maybe SymbolHandle),
-               ("marks",) <$> (args !? #marks :: Maybe SymbolHandle),
-               ("valid_length",) <$>
-                 (args !? #valid_length :: Maybe SymbolHandle),
-               ("max_time",) <$> (args !? #max_time :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_hawkesll"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_backward_hawkesll(symbol)" =
-     '[]
-
-_contrib_backward_hawkesll ::
-                           forall args .
-                             Fullfilled "_contrib_backward_hawkesll(symbol)" args =>
-                             String ->
-                               ArgsHMap "_contrib_backward_hawkesll(symbol)" args ->
-                                 IO SymbolHandle
-_contrib_backward_hawkesll name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_hawkesll"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_mp_adamw_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("eta", AttrReq Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle),
-        '("weight32", AttrOpt SymbolHandle),
-        '("rescale_grad", AttrOpt SymbolHandle)]
-
-_mp_adamw_update ::
-                 forall args . Fullfilled "_mp_adamw_update(symbol)" args =>
-                   String ->
-                     ArgsHMap "_mp_adamw_update(symbol)" args -> IO SymbolHandle
-_mp_adamw_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("eta",) . showValue <$> (args !? #eta :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mean",) <$> (args !? #mean :: Maybe SymbolHandle),
-               ("var",) <$> (args !? #var :: Maybe SymbolHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle),
-               ("rescale_grad",) <$>
-                 (args !? #rescale_grad :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_mp_adamw_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_adamw_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("eta", AttrReq Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle),
-        '("rescale_grad", AttrOpt SymbolHandle)]
-
-_adamw_update ::
-              forall args . Fullfilled "_adamw_update(symbol)" args =>
-                String -> ArgsHMap "_adamw_update(symbol)" args -> IO SymbolHandle
-_adamw_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("eta",) . showValue <$> (args !? #eta :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mean",) <$> (args !? #mean :: Maybe SymbolHandle),
-               ("var",) <$> (args !? #var :: Maybe SymbolHandle),
-               ("rescale_grad",) <$>
-                 (args !? #rescale_grad :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_adamw_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quadratic(symbol)" =
-     '[ '("a", AttrOpt Float), '("b", AttrOpt Float),
-        '("c", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_contrib_quadratic ::
-                   forall args . Fullfilled "_contrib_quadratic(symbol)" args =>
-                     String ->
-                       ArgsHMap "_contrib_quadratic(symbol)" args -> IO SymbolHandle
-_contrib_quadratic name args
-  = let scalarArgs
-          = catMaybes
-              [("a",) . showValue <$> (args !? #a :: Maybe Float),
-               ("b",) . showValue <$> (args !? #b :: Maybe Float),
-               ("c",) . showValue <$> (args !? #c :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quadratic"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_backward_quadratic(symbol)" =
-     '[]
-
-_contrib_backward_quadratic ::
-                            forall args .
-                              Fullfilled "_contrib_backward_quadratic(symbol)" args =>
-                              String ->
-                                ArgsHMap "_contrib_backward_quadratic(symbol)" args ->
-                                  IO SymbolHandle
-_contrib_backward_quadratic name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_quadratic"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_div_sqrt_dim(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_contrib_div_sqrt_dim ::
-                      forall args . Fullfilled "_contrib_div_sqrt_dim(symbol)" args =>
-                        String ->
-                          ArgsHMap "_contrib_div_sqrt_dim(symbol)" args -> IO SymbolHandle
-_contrib_div_sqrt_dim name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_div_sqrt_dim"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "multi_all_finite(symbol)" =
-     '[ '("num_arrays", AttrOpt Int), '("init_output", AttrOpt Bool),
-        '("data", AttrOpt [SymbolHandle])]
-
-multi_all_finite ::
-                 forall args . Fullfilled "multi_all_finite(symbol)" args =>
-                   String ->
-                     ArgsHMap "multi_all_finite(symbol)" args -> IO SymbolHandle
-multi_all_finite name args
-  = let scalarArgs
-          = catMaybes
-              [("num_arrays",) . showValue <$>
-                 (args !? #num_arrays :: Maybe Int),
-               ("init_output",) . showValue <$>
-                 (args !? #init_output :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "multi_all_finite"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_contrib_index_array(symbol)" =
-     '[ '("axes", AttrOpt (Maybe [Int])),
-        '("data", AttrOpt SymbolHandle)]
-
-_contrib_index_array ::
-                     forall args . Fullfilled "_contrib_index_array(symbol)" args =>
-                       String ->
-                         ArgsHMap "_contrib_index_array(symbol)" args -> IO SymbolHandle
-_contrib_index_array name args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_index_array"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_index_copy(symbol)" =
-     '[ '("old_tensor", AttrOpt SymbolHandle),
-        '("index_vector", AttrOpt SymbolHandle),
-        '("new_tensor", AttrOpt SymbolHandle)]
-
-_contrib_index_copy ::
-                    forall args . Fullfilled "_contrib_index_copy(symbol)" args =>
-                      String ->
-                        ArgsHMap "_contrib_index_copy(symbol)" args -> IO SymbolHandle
-_contrib_index_copy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("old_tensor",) <$> (args !? #old_tensor :: Maybe SymbolHandle),
-               ("index_vector",) <$>
-                 (args !? #index_vector :: Maybe SymbolHandle),
-               ("new_tensor",) <$> (args !? #new_tensor :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_index_copy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_backward_index_copy(symbol)"
-     = '[]
-
-_contrib_backward_index_copy ::
-                             forall args .
-                               Fullfilled "_contrib_backward_index_copy(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_contrib_backward_index_copy(symbol)" args ->
-                                   IO SymbolHandle
-_contrib_backward_index_copy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_backward_index_copy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_ROIAlign(symbol)" =
-     '[ '("pooled_size", AttrReq [Int]),
-        '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int),
-        '("position_sensitive", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)]
-
-_contrib_ROIAlign ::
-                  forall args . Fullfilled "_contrib_ROIAlign(symbol)" args =>
-                    String ->
-                      ArgsHMap "_contrib_ROIAlign(symbol)" args -> IO SymbolHandle
-_contrib_ROIAlign name args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("sample_ratio",) . showValue <$>
-                 (args !? #sample_ratio :: Maybe Int),
-               ("position_sensitive",) . showValue <$>
-                 (args !? #position_sensitive :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ROIAlign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_ROIAlign(symbol)" = '[]
-
-_backward_ROIAlign ::
-                   forall args . Fullfilled "_backward_ROIAlign(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_ROIAlign(symbol)" args -> IO SymbolHandle
-_backward_ROIAlign name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIAlign"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_box_nms(symbol)" =
-     '[ '("overlap_thresh", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),
-        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),
-        '("id_index", AttrOpt Int), '("background_id", AttrOpt Int),
-        '("force_suppress", AttrOpt Bool),
-        '("in_format", AttrOpt (EnumType '["center", "corner"])),
-        '("out_format", AttrOpt (EnumType '["center", "corner"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_contrib_box_nms ::
-                 forall args . Fullfilled "_contrib_box_nms(symbol)" args =>
-                   String ->
-                     ArgsHMap "_contrib_box_nms(symbol)" args -> IO SymbolHandle
-_contrib_box_nms name args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_nms"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_contrib_box_nms(symbol)" =
-     '[ '("overlap_thresh", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),
-        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),
-        '("id_index", AttrOpt Int), '("background_id", AttrOpt Int),
-        '("force_suppress", AttrOpt Bool),
-        '("in_format", AttrOpt (EnumType '["center", "corner"])),
-        '("out_format", AttrOpt (EnumType '["center", "corner"]))]
-
-_backward_contrib_box_nms ::
-                          forall args .
-                            Fullfilled "_backward_contrib_box_nms(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_contrib_box_nms(symbol)" args ->
-                                IO SymbolHandle
-_backward_contrib_box_nms name args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_thresh",) . showValue <$>
-                 (args !? #overlap_thresh :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
-               ("coord_start",) . showValue <$>
-                 (args !? #coord_start :: Maybe Int),
-               ("score_index",) . showValue <$>
-                 (args !? #score_index :: Maybe Int),
-               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("in_format",) . showValue <$>
-                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
-               ("out_format",) . showValue <$>
-                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_nms"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_box_iou(symbol)" =
-     '[ '("format", AttrOpt (EnumType '["center", "corner"])),
-        '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle)]
-
-_contrib_box_iou ::
-                 forall args . Fullfilled "_contrib_box_iou(symbol)" args =>
-                   String ->
-                     ArgsHMap "_contrib_box_iou(symbol)" args -> IO SymbolHandle
-_contrib_box_iou name args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_box_iou"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_contrib_box_iou(symbol)" =
-     '[ '("format", AttrOpt (EnumType '["center", "corner"]))]
-
-_backward_contrib_box_iou ::
-                          forall args .
-                            Fullfilled "_backward_contrib_box_iou(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_contrib_box_iou(symbol)" args ->
-                                IO SymbolHandle
-_backward_contrib_box_iou name args
-  = let scalarArgs
-          = catMaybes
-              [("format",) . showValue <$>
-                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_box_iou"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_bipartite_matching(symbol)" =
-     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),
-        '("topk", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-_contrib_bipartite_matching ::
-                            forall args .
-                              Fullfilled "_contrib_bipartite_matching(symbol)" args =>
-                              String ->
-                                ArgsHMap "_contrib_bipartite_matching(symbol)" args ->
-                                  IO SymbolHandle
-_contrib_bipartite_matching name args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_bipartite_matching"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_contrib_bipartite_matching(symbol)" =
-     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),
-        '("topk", AttrOpt Int)]
-
-_backward_contrib_bipartite_matching ::
-                                     forall args .
-                                       Fullfilled "_backward_contrib_bipartite_matching(symbol)"
-                                         args =>
-                                       String ->
-                                         ArgsHMap "_backward_contrib_bipartite_matching(symbol)"
-                                           args
-                                           -> IO SymbolHandle
-_backward_contrib_bipartite_matching name args
-  = let scalarArgs
-          = catMaybes
-              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_bipartite_matching"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_BilinearResize2D(symbol)" =
-     '[ '("height", AttrOpt Int), '("width", AttrOpt Int),
-        '("scale_height", AttrOpt (Maybe Float)),
-        '("scale_width", AttrOpt (Maybe Float)),
-        '("mode",
-          AttrOpt
-            (EnumType
-               '["like", "odd_scale", "size", "to_even_down", "to_even_up",
-                 "to_odd_down", "to_odd_up"])),
-        '("data", AttrOpt SymbolHandle), '("like", AttrOpt SymbolHandle)]
-
-_contrib_BilinearResize2D ::
-                          forall args .
-                            Fullfilled "_contrib_BilinearResize2D(symbol)" args =>
-                            String ->
-                              ArgsHMap "_contrib_BilinearResize2D(symbol)" args ->
-                                IO SymbolHandle
-_contrib_BilinearResize2D name args
-  = let scalarArgs
-          = catMaybes
-              [("height",) . showValue <$> (args !? #height :: Maybe Int),
-               ("width",) . showValue <$> (args !? #width :: Maybe Int),
-               ("scale_height",) . showValue <$>
-                 (args !? #scale_height :: Maybe (Maybe Float)),
-               ("scale_width",) . showValue <$>
-                 (args !? #scale_width :: Maybe (Maybe Float)),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe
-                      (EnumType
-                         '["like", "odd_scale", "size", "to_even_down", "to_even_up",
-                           "to_odd_down", "to_odd_up"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("like",) <$> (args !? #like :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_BilinearResize2D"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_contrib_BilinearResize2D(symbol)" = '[]
-
-_backward_contrib_BilinearResize2D ::
-                                   forall args .
-                                     Fullfilled "_backward_contrib_BilinearResize2D(symbol)" args =>
-                                     String ->
-                                       ArgsHMap "_backward_contrib_BilinearResize2D(symbol)" args ->
-                                         IO SymbolHandle
-_backward_contrib_BilinearResize2D name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_BilinearResize2D"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_boolean_mask(symbol)" =
-     '[ '("axis", AttrOpt Int), '("data", AttrOpt SymbolHandle),
-        '("index", AttrOpt SymbolHandle)]
-
-_contrib_boolean_mask ::
-                      forall args . Fullfilled "_contrib_boolean_mask(symbol)" args =>
-                        String ->
-                          ArgsHMap "_contrib_boolean_mask(symbol)" args -> IO SymbolHandle
-_contrib_boolean_mask name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("index",) <$> (args !? #index :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_boolean_mask"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_contrib_boolean_mask(symbol)" =
-     '[ '("axis", AttrOpt Int)]
-
-_backward_contrib_boolean_mask ::
-                               forall args .
-                                 Fullfilled "_backward_contrib_boolean_mask(symbol)" args =>
-                                 String ->
-                                   ArgsHMap "_backward_contrib_boolean_mask(symbol)" args ->
-                                     IO SymbolHandle
-_backward_contrib_boolean_mask name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_boolean_mask"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_SyncBatchNorm(symbol)" =
-     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int),
-        '("key", AttrReq String), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),
-        '("moving_mean", AttrOpt SymbolHandle),
-        '("moving_var", AttrOpt SymbolHandle)]
-
-_contrib_SyncBatchNorm ::
-                       forall args . Fullfilled "_contrib_SyncBatchNorm(symbol)" args =>
-                         String ->
-                           ArgsHMap "_contrib_SyncBatchNorm(symbol)" args -> IO SymbolHandle
-_contrib_SyncBatchNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),
-               ("key",) . showValue <$> (args !? #key :: Maybe String)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_SyncBatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_AdaptiveAvgPooling2D(symbol)"
-     =
-     '[ '("output_size", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-_contrib_AdaptiveAvgPooling2D ::
-                              forall args .
-                                Fullfilled "_contrib_AdaptiveAvgPooling2D(symbol)" args =>
-                                String ->
-                                  ArgsHMap "_contrib_AdaptiveAvgPooling2D(symbol)" args ->
-                                    IO SymbolHandle
-_contrib_AdaptiveAvgPooling2D name args
-  = let scalarArgs
-          = catMaybes
-              [("output_size",) . showValue <$>
-                 (args !? #output_size :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_AdaptiveAvgPooling2D"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_contrib_AdaptiveAvgPooling2D(symbol)" =
-     '[]
-
-_backward_contrib_AdaptiveAvgPooling2D ::
-                                       forall args .
-                                         Fullfilled "_backward_contrib_AdaptiveAvgPooling2D(symbol)"
-                                           args =>
-                                         String ->
-                                           ArgsHMap "_backward_contrib_AdaptiveAvgPooling2D(symbol)"
-                                             args
-                                             -> IO SymbolHandle
-_backward_contrib_AdaptiveAvgPooling2D name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_contrib_AdaptiveAvgPooling2D"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_crop(symbol)" =
-     '[ '("x", AttrReq Int), '("y", AttrReq Int),
-        '("width", AttrReq Int), '("height", AttrReq Int),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_crop ::
-            forall args . Fullfilled "_image_crop(symbol)" args =>
-              String -> ArgsHMap "_image_crop(symbol)" args -> IO SymbolHandle
-_image_crop name args
-  = let scalarArgs
-          = catMaybes
-              [("x",) . showValue <$> (args !? #x :: Maybe Int),
-               ("y",) . showValue <$> (args !? #y :: Maybe Int),
-               ("width",) . showValue <$> (args !? #width :: Maybe Int),
-               ("height",) . showValue <$> (args !? #height :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_crop"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_image_crop(symbol)" = '[]
-
-_backward_image_crop ::
-                     forall args . Fullfilled "_backward_image_crop(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_image_crop(symbol)" args -> IO SymbolHandle
-_backward_image_crop name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_image_crop"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_to_tensor(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_image_to_tensor ::
-                 forall args . Fullfilled "_image_to_tensor(symbol)" args =>
-                   String ->
-                     ArgsHMap "_image_to_tensor(symbol)" args -> IO SymbolHandle
-_image_to_tensor name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_to_tensor"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_normalize(symbol)" =
-     '[ '("mean", AttrOpt [Float]), '("std", AttrOpt [Float]),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_normalize ::
-                 forall args . Fullfilled "_image_normalize(symbol)" args =>
-                   String ->
-                     ArgsHMap "_image_normalize(symbol)" args -> IO SymbolHandle
-_image_normalize name args
-  = let scalarArgs
-          = catMaybes
-              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),
-               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_normalize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_image_normalize(symbol)" =
-     '[]
-
-_backward_image_normalize ::
-                          forall args .
-                            Fullfilled "_backward_image_normalize(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_image_normalize(symbol)" args ->
-                                IO SymbolHandle
-_backward_image_normalize name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_image_normalize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_flip_left_right(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_image_flip_left_right ::
-                       forall args . Fullfilled "_image_flip_left_right(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_flip_left_right(symbol)" args -> IO SymbolHandle
-_image_flip_left_right name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_left_right"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_flip_left_right(symbol)"
-     = '[ '("data", AttrOpt SymbolHandle)]
-
-_image_random_flip_left_right ::
-                              forall args .
-                                Fullfilled "_image_random_flip_left_right(symbol)" args =>
-                                String ->
-                                  ArgsHMap "_image_random_flip_left_right(symbol)" args ->
-                                    IO SymbolHandle
-_image_random_flip_left_right name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_left_right"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_flip_top_bottom(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle)]
-
-_image_flip_top_bottom ::
-                       forall args . Fullfilled "_image_flip_top_bottom(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_flip_top_bottom(symbol)" args -> IO SymbolHandle
-_image_flip_top_bottom name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_flip_top_bottom"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_flip_top_bottom(symbol)"
-     = '[ '("data", AttrOpt SymbolHandle)]
-
-_image_random_flip_top_bottom ::
-                              forall args .
-                                Fullfilled "_image_random_flip_top_bottom(symbol)" args =>
-                                String ->
-                                  ArgsHMap "_image_random_flip_top_bottom(symbol)" args ->
-                                    IO SymbolHandle
-_image_random_flip_top_bottom name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_flip_top_bottom"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_brightness(symbol)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_brightness ::
-                         forall args . Fullfilled "_image_random_brightness(symbol)" args =>
-                           String ->
-                             ArgsHMap "_image_random_brightness(symbol)" args -> IO SymbolHandle
-_image_random_brightness name args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_brightness"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_contrast(symbol)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_contrast ::
-                       forall args . Fullfilled "_image_random_contrast(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_random_contrast(symbol)" args -> IO SymbolHandle
-_image_random_contrast name args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_contrast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_saturation(symbol)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_saturation ::
-                         forall args . Fullfilled "_image_random_saturation(symbol)" args =>
-                           String ->
-                             ArgsHMap "_image_random_saturation(symbol)" args -> IO SymbolHandle
-_image_random_saturation name args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_saturation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_hue(symbol)" =
-     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_hue ::
-                  forall args . Fullfilled "_image_random_hue(symbol)" args =>
-                    String ->
-                      ArgsHMap "_image_random_hue(symbol)" args -> IO SymbolHandle
-_image_random_hue name args
-  = let scalarArgs
-          = catMaybes
-              [("min_factor",) . showValue <$>
-                 (args !? #min_factor :: Maybe Float),
-               ("max_factor",) . showValue <$>
-                 (args !? #max_factor :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_hue"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_color_jitter(symbol)" =
-     '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float),
-        '("saturation", AttrReq Float), '("hue", AttrReq Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_image_random_color_jitter ::
-                           forall args .
-                             Fullfilled "_image_random_color_jitter(symbol)" args =>
-                             String ->
-                               ArgsHMap "_image_random_color_jitter(symbol)" args ->
-                                 IO SymbolHandle
-_image_random_color_jitter name args
-  = let scalarArgs
-          = catMaybes
-              [("brightness",) . showValue <$>
-                 (args !? #brightness :: Maybe Float),
-               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
-               ("saturation",) . showValue <$>
-                 (args !? #saturation :: Maybe Float),
-               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_color_jitter"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_adjust_lighting(symbol)" =
-     '[ '("alpha", AttrReq [Float]), '("data", AttrOpt SymbolHandle)]
-
-_image_adjust_lighting ::
-                       forall args . Fullfilled "_image_adjust_lighting(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_adjust_lighting(symbol)" args -> IO SymbolHandle
-_image_adjust_lighting name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_adjust_lighting"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_random_lighting(symbol)" =
-     '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt SymbolHandle)]
-
-_image_random_lighting ::
-                       forall args . Fullfilled "_image_random_lighting(symbol)" args =>
-                         String ->
-                           ArgsHMap "_image_random_lighting(symbol)" args -> IO SymbolHandle
-_image_random_lighting name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha_std",) . showValue <$>
-                 (args !? #alpha_std :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_random_lighting"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_image_resize(symbol)" =
-     '[ '("size", AttrOpt [Int]), '("keep_ratio", AttrOpt Bool),
-        '("interp", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-_image_resize ::
-              forall args . Fullfilled "_image_resize(symbol)" args =>
-                String -> ArgsHMap "_image_resize(symbol)" args -> IO SymbolHandle
-_image_resize name args
-  = let scalarArgs
-          = catMaybes
-              [("size",) . showValue <$> (args !? #size :: Maybe [Int]),
-               ("keep_ratio",) . showValue <$>
-                 (args !? #keep_ratio :: Maybe Bool),
-               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_image_resize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "moments(symbol)" =
-     '[ '("axes", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle)]
-
-moments ::
-        forall args . Fullfilled "moments(symbol)" args =>
-          String -> ArgsHMap "moments(symbol)" args -> IO SymbolHandle
-moments name args
-  = let scalarArgs
-          = catMaybes
-              [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int])),
-               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "moments"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_moments(symbol)" = '[]
-
-_backward_moments ::
-                  forall args . Fullfilled "_backward_moments(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_moments(symbol)" args -> IO SymbolHandle
-_backward_moments name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_moments"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "softmax(symbol)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("dtype",
-          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),
-        '("data", AttrOpt SymbolHandle)]
-
-softmax ::
-        forall args . Fullfilled "softmax(symbol)" args =>
-          String -> ArgsHMap "softmax(symbol)" args -> IO SymbolHandle
-softmax name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double)),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_softmax(symbol)" =
-     '[ '("args", AttrOpt [SymbolHandle])]
-
-_backward_softmax ::
-                  forall args . Fullfilled "_backward_softmax(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_softmax(symbol)" args -> IO SymbolHandle
-_backward_softmax name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "_backward_softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "softmin(symbol)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("dtype",
-          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),
-        '("data", AttrOpt SymbolHandle)]
-
-softmin ::
-        forall args . Fullfilled "softmin(symbol)" args =>
-          String -> ArgsHMap "softmin(symbol)" args -> IO SymbolHandle
-softmin name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double)),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_softmin(symbol)" =
-     '[ '("args", AttrOpt [SymbolHandle])]
-
-_backward_softmin ::
-                  forall args . Fullfilled "_backward_softmin(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_softmin(symbol)" args -> IO SymbolHandle
-_backward_softmin name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "_backward_softmin"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "log_softmax(symbol)" =
-     '[ '("axis", AttrOpt Int),
-        '("temperature", AttrOpt (Maybe Double)),
-        '("dtype",
-          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),
-        '("data", AttrOpt SymbolHandle)]
-
-log_softmax ::
-            forall args . Fullfilled "log_softmax(symbol)" args =>
-              String -> ArgsHMap "log_softmax(symbol)" args -> IO SymbolHandle
-log_softmax name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("temperature",) . showValue <$>
-                 (args !? #temperature :: Maybe (Maybe Double)),
-               ("dtype",) . showValue <$>
-                 (args !? #dtype ::
-                    Maybe (Maybe (EnumType '["float16", "float32", "float64"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "log_softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_log_softmax(symbol)" =
-     '[ '("args", AttrOpt [SymbolHandle])]
-
-_backward_log_softmax ::
-                      forall args . Fullfilled "_backward_log_softmax(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_log_softmax(symbol)" args -> IO SymbolHandle
-_backward_log_softmax name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #args :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "_backward_log_softmax"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_Pooling(symbol)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),
-        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
-        '("pooling_convention",
-          AttrOpt (EnumType '["full", "same", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("p_value", AttrOpt (Maybe Int)),
-        '("count_include_pad", AttrOpt (Maybe Bool)),
-        '("layout",
-          AttrOpt
-            (Maybe
-               (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"]))),
-        '("data", AttrOpt SymbolHandle)]
-
-_Pooling ::
-         forall args . Fullfilled "_Pooling(symbol)" args =>
-           String -> ArgsHMap "_Pooling(symbol)" args -> IO SymbolHandle
-_Pooling name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "same", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool)),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe
-                         (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Pooling(symbol)" = '[]
-
-_backward_Pooling ::
-                  forall args . Fullfilled "_backward_Pooling(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_Pooling(symbol)" args -> IO SymbolHandle
-_backward_Pooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Deconvolution(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle)]
-
-_Deconvolution ::
-               forall args . Fullfilled "_Deconvolution(symbol)" args =>
-                 String -> ArgsHMap "_Deconvolution(symbol)" args -> IO SymbolHandle
-_Deconvolution name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Deconvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Deconvolution(symbol)" = '[]
-
-_backward_Deconvolution ::
-                        forall args . Fullfilled "_backward_Deconvolution(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_Deconvolution(symbol)" args -> IO SymbolHandle
-_backward_Deconvolution name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Deconvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Activation(symbol)" =
-     '[ '("act_type",
-          AttrReq
-            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_Activation ::
-            forall args . Fullfilled "_Activation(symbol)" args =>
-              String -> ArgsHMap "_Activation(symbol)" args -> IO SymbolHandle
-_Activation name args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Activation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Activation(symbol)" = '[]
-
-_backward_Activation ::
-                     forall args . Fullfilled "_backward_Activation(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_Activation(symbol)" args -> IO SymbolHandle
-_backward_Activation name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Activation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_UpSampling(symbol)" =
-     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),
-        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),
-        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),
-        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-_UpSampling ::
-            forall args . Fullfilled "_UpSampling(symbol)" args =>
-              String -> ArgsHMap "_UpSampling(symbol)" args -> IO SymbolHandle
-_UpSampling name args
-  = let scalarArgs
-          = catMaybes
-              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("sample_type",) . showValue <$>
-                 (args !? #sample_type ::
-                    Maybe (EnumType '["bilinear", "nearest"])),
-               ("multi_input_mode",) . showValue <$>
-                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),
-               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "UpSampling"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_UpSampling(symbol)" = '[]
-
-_backward_UpSampling ::
-                     forall args . Fullfilled "_backward_UpSampling(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_UpSampling(symbol)" args -> IO SymbolHandle
-_backward_UpSampling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_UpSampling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BatchNorm(symbol)" =
-     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("cudnn_off", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle),
-        '("moving_mean", AttrOpt SymbolHandle),
-        '("moving_var", AttrOpt SymbolHandle)]
-
-_BatchNorm ::
-           forall args . Fullfilled "_BatchNorm(symbol)" args =>
-             String -> ArgsHMap "_BatchNorm(symbol)" args -> IO SymbolHandle
-_BatchNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle),
-               ("moving_mean",) <$> (args !? #moving_mean :: Maybe SymbolHandle),
-               ("moving_var",) <$> (args !? #moving_var :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_BatchNorm(symbol)" = '[]
-
-_backward_BatchNorm ::
-                    forall args . Fullfilled "_backward_BatchNorm(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_BatchNorm(symbol)" args -> IO SymbolHandle
-_backward_BatchNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CTCLoss(symbol)" =
-     '[ '("use_data_lengths", AttrOpt Bool),
-        '("use_label_lengths", AttrOpt Bool),
-        '("blank_label", AttrOpt (EnumType '["first", "last"])),
-        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle),
-        '("data_lengths", AttrOpt SymbolHandle),
-        '("label_lengths", AttrOpt SymbolHandle)]
-
-_CTCLoss ::
-         forall args . Fullfilled "_CTCLoss(symbol)" args =>
-           String -> ArgsHMap "_CTCLoss(symbol)" args -> IO SymbolHandle
-_CTCLoss name args
-  = let scalarArgs
-          = catMaybes
-              [("use_data_lengths",) . showValue <$>
-                 (args !? #use_data_lengths :: Maybe Bool),
-               ("use_label_lengths",) . showValue <$>
-                 (args !? #use_label_lengths :: Maybe Bool),
-               ("blank_label",) . showValue <$>
-                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle),
-               ("data_lengths",) <$>
-                 (args !? #data_lengths :: Maybe SymbolHandle),
-               ("label_lengths",) <$>
-                 (args !? #label_lengths :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "CTCLoss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_ctc_loss(symbol)" = '[]
-
-_backward_ctc_loss ::
-                   forall args . Fullfilled "_backward_ctc_loss(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_ctc_loss(symbol)" args -> IO SymbolHandle
-_backward_ctc_loss name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ctc_loss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_FullyConnected(symbol)" =
-     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
-        '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]
-
-_FullyConnected ::
-                forall args . Fullfilled "_FullyConnected(symbol)" args =>
-                  String ->
-                    ArgsHMap "_FullyConnected(symbol)" args -> IO SymbolHandle
-_FullyConnected name args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "FullyConnected"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_FullyConnected(symbol)" =
-     '[]
-
-_backward_FullyConnected ::
-                         forall args . Fullfilled "_backward_FullyConnected(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_FullyConnected(symbol)" args -> IO SymbolHandle
-_backward_FullyConnected name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_FullyConnected"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Convolution(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle)]
-
-_Convolution ::
-             forall args . Fullfilled "_Convolution(symbol)" args =>
-               String -> ArgsHMap "_Convolution(symbol)" args -> IO SymbolHandle
-_Convolution name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Convolution(symbol)" = '[]
-
-_backward_Convolution ::
-                      forall args . Fullfilled "_backward_Convolution(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_Convolution(symbol)" args -> IO SymbolHandle
-_backward_Convolution name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LayerNorm(symbol)" =
-     '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float),
-        '("output_mean_var", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle),
-        '("beta", AttrOpt SymbolHandle)]
-
-_LayerNorm ::
-           forall args . Fullfilled "_LayerNorm(symbol)" args =>
-             String -> ArgsHMap "_LayerNorm(symbol)" args -> IO SymbolHandle
-_LayerNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LayerNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_LayerNorm(symbol)" = '[]
-
-_backward_LayerNorm ::
-                    forall args . Fullfilled "_backward_LayerNorm(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_LayerNorm(symbol)" args -> IO SymbolHandle
-_backward_LayerNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LayerNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Concat(symbol)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-_Concat ::
-        forall args . Fullfilled "_Concat(symbol)" args =>
-          String -> ArgsHMap "_Concat(symbol)" args -> IO SymbolHandle
-_Concat name args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "Concat"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_Concat(symbol)" = '[]
-
-_backward_Concat ::
-                 forall args . Fullfilled "_backward_Concat(symbol)" args =>
-                   String ->
-                     ArgsHMap "_backward_Concat(symbol)" args -> IO SymbolHandle
-_backward_Concat name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Concat"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_rnn_param_concat(symbol)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-_rnn_param_concat ::
-                  forall args . Fullfilled "_rnn_param_concat(symbol)" args =>
-                    String ->
-                      ArgsHMap "_rnn_param_concat(symbol)" args -> IO SymbolHandle
-_rnn_param_concat name args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "_rnn_param_concat"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_SoftmaxActivation(symbol)" =
-     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_SoftmaxActivation ::
-                   forall args . Fullfilled "_SoftmaxActivation(symbol)" args =>
-                     String ->
-                       ArgsHMap "_SoftmaxActivation(symbol)" args -> IO SymbolHandle
-_SoftmaxActivation name args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxActivation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SoftmaxActivation(symbol)" =
-     '[]
-
-_backward_SoftmaxActivation ::
-                            forall args .
-                              Fullfilled "_backward_SoftmaxActivation(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward_SoftmaxActivation(symbol)" args ->
-                                  IO SymbolHandle
-_backward_SoftmaxActivation name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxActivation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LRN(symbol)" =
-     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
-        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),
-        '("data", AttrOpt SymbolHandle)]
-
-_LRN ::
-     forall args . Fullfilled "_LRN(symbol)" args =>
-       String -> ArgsHMap "_LRN(symbol)" args -> IO SymbolHandle
-_LRN name args
-  = let scalarArgs
-          = catMaybes
-              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),
-               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LRN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_LRN(symbol)" = '[]
-
-_backward_LRN ::
-              forall args . Fullfilled "_backward_LRN(symbol)" args =>
-                String -> ArgsHMap "_backward_LRN(symbol)" args -> IO SymbolHandle
-_backward_LRN name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LRN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Dropout(symbol)" =
-     '[ '("p", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["always", "training"])),
-        '("axes", AttrOpt [Int]), '("cudnn_off", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt SymbolHandle)]
-
-_Dropout ::
-         forall args . Fullfilled "_Dropout(symbol)" args =>
-           String -> ArgsHMap "_Dropout(symbol)" args -> IO SymbolHandle
-_Dropout name args
-  = let scalarArgs
-          = catMaybes
-              [("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode :: Maybe (EnumType '["always", "training"])),
-               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int]),
-               ("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Dropout"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Dropout(symbol)" = '[]
-
-_backward_Dropout ::
-                  forall args . Fullfilled "_backward_Dropout(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_Dropout(symbol)" args -> IO SymbolHandle
-_backward_Dropout name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Dropout"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_contrib_quantized_elemwise_add(symbol)" =
-     '[ '("lhs", AttrOpt SymbolHandle), '("rhs", AttrOpt SymbolHandle),
-        '("lhs_min", AttrOpt SymbolHandle),
-        '("lhs_max", AttrOpt SymbolHandle),
-        '("rhs_min", AttrOpt SymbolHandle),
-        '("rhs_max", AttrOpt SymbolHandle)]
-
-_contrib_quantized_elemwise_add ::
-                                forall args .
-                                  Fullfilled "_contrib_quantized_elemwise_add(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_contrib_quantized_elemwise_add(symbol)" args ->
-                                      IO SymbolHandle
-_contrib_quantized_elemwise_add name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("lhs",) <$> (args !? #lhs :: Maybe SymbolHandle),
-               ("rhs",) <$> (args !? #rhs :: Maybe SymbolHandle),
-               ("lhs_min",) <$> (args !? #lhs_min :: Maybe SymbolHandle),
-               ("lhs_max",) <$> (args !? #lhs_max :: Maybe SymbolHandle),
-               ("rhs_min",) <$> (args !? #rhs_min :: Maybe SymbolHandle),
-               ("rhs_max",) <$> (args !? #rhs_max :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_elemwise_add"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_dequantize(symbol)" =
-     '[ '("out_type", AttrOpt (EnumType '["float32"])),
-        '("data", AttrOpt SymbolHandle),
-        '("min_range", AttrOpt SymbolHandle),
-        '("max_range", AttrOpt SymbolHandle)]
-
-_contrib_dequantize ::
-                    forall args . Fullfilled "_contrib_dequantize(symbol)" args =>
-                      String ->
-                        ArgsHMap "_contrib_dequantize(symbol)" args -> IO SymbolHandle
-_contrib_dequantize name args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["float32"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_dequantize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantized_flatten(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("min_data", AttrOpt SymbolHandle),
-        '("max_data", AttrOpt SymbolHandle)]
-
-_contrib_quantized_flatten ::
-                           forall args .
-                             Fullfilled "_contrib_quantized_flatten(symbol)" args =>
-                             String ->
-                               ArgsHMap "_contrib_quantized_flatten(symbol)" args ->
-                                 IO SymbolHandle
-_contrib_quantized_flatten name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_flatten"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantized_conv(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt
-            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle),
-        '("min_data", AttrOpt SymbolHandle),
-        '("max_data", AttrOpt SymbolHandle),
-        '("min_weight", AttrOpt SymbolHandle),
-        '("max_weight", AttrOpt SymbolHandle),
-        '("min_bias", AttrOpt SymbolHandle),
-        '("max_bias", AttrOpt SymbolHandle)]
-
-_contrib_quantized_conv ::
-                        forall args . Fullfilled "_contrib_quantized_conv(symbol)" args =>
-                          String ->
-                            ArgsHMap "_contrib_quantized_conv(symbol)" args -> IO SymbolHandle
-_contrib_quantized_conv name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_conv"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_contrib_quantized_fully_connected(symbol)" =
-     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
-        '("flatten", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle),
-        '("min_data", AttrOpt SymbolHandle),
-        '("max_data", AttrOpt SymbolHandle),
-        '("min_weight", AttrOpt SymbolHandle),
-        '("max_weight", AttrOpt SymbolHandle),
-        '("min_bias", AttrOpt SymbolHandle),
-        '("max_bias", AttrOpt SymbolHandle)]
-
-_contrib_quantized_fully_connected ::
-                                   forall args .
-                                     Fullfilled "_contrib_quantized_fully_connected(symbol)" args =>
-                                     String ->
-                                       ArgsHMap "_contrib_quantized_fully_connected(symbol)" args ->
-                                         IO SymbolHandle
-_contrib_quantized_fully_connected name args
-  = let scalarArgs
-          = catMaybes
-              [("num_hidden",) . showValue <$>
-                 (args !? #num_hidden :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle),
-               ("min_weight",) <$> (args !? #min_weight :: Maybe SymbolHandle),
-               ("max_weight",) <$> (args !? #max_weight :: Maybe SymbolHandle),
-               ("min_bias",) <$> (args !? #min_bias :: Maybe SymbolHandle),
-               ("max_bias",) <$> (args !? #max_bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_fully_connected"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantized_pooling(symbol)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),
-        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
-        '("pooling_convention",
-          AttrOpt (EnumType '["full", "same", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("p_value", AttrOpt (Maybe Int)),
-        '("count_include_pad", AttrOpt (Maybe Bool)),
-        '("layout",
-          AttrOpt
-            (Maybe
-               (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"]))),
-        '("data", AttrOpt SymbolHandle),
-        '("min_data", AttrOpt SymbolHandle),
-        '("max_data", AttrOpt SymbolHandle)]
-
-_contrib_quantized_pooling ::
-                           forall args .
-                             Fullfilled "_contrib_quantized_pooling(symbol)" args =>
-                             String ->
-                               ArgsHMap "_contrib_quantized_pooling(symbol)" args ->
-                                 IO SymbolHandle
-_contrib_quantized_pooling name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type ::
-                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "same", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("p_value",) . showValue <$>
-                 (args !? #p_value :: Maybe (Maybe Int)),
-               ("count_include_pad",) . showValue <$>
-                 (args !? #count_include_pad :: Maybe (Maybe Bool)),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe
-                      (Maybe
-                         (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_pooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantize_v2(symbol)" =
-     '[ '("out_type", AttrOpt (EnumType '["auto", "int8", "uint8"])),
-        '("min_calib_range", AttrOpt (Maybe Float)),
-        '("max_calib_range", AttrOpt (Maybe Float)),
-        '("data", AttrOpt SymbolHandle)]
-
-_contrib_quantize_v2 ::
-                     forall args . Fullfilled "_contrib_quantize_v2(symbol)" args =>
-                       String ->
-                         ArgsHMap "_contrib_quantize_v2(symbol)" args -> IO SymbolHandle
-_contrib_quantize_v2 name args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])),
-               ("min_calib_range",) . showValue <$>
-                 (args !? #min_calib_range :: Maybe (Maybe Float)),
-               ("max_calib_range",) . showValue <$>
-                 (args !? #max_calib_range :: Maybe (Maybe Float))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize_v2"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantized_concat(symbol)" =
-     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-_contrib_quantized_concat ::
-                          forall args .
-                            Fullfilled "_contrib_quantized_concat(symbol)" args =>
-                            String ->
-                              ArgsHMap "_contrib_quantized_concat(symbol)" args ->
-                                IO SymbolHandle
-_contrib_quantized_concat name args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_concat"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_contrib_requantize(symbol)" =
-     '[ '("out_type", AttrOpt (EnumType '["auto", "int8", "uint8"])),
-        '("min_calib_range", AttrOpt (Maybe Float)),
-        '("max_calib_range", AttrOpt (Maybe Float)),
-        '("data", AttrOpt SymbolHandle),
-        '("min_range", AttrOpt SymbolHandle),
-        '("max_range", AttrOpt SymbolHandle)]
-
-_contrib_requantize ::
-                    forall args . Fullfilled "_contrib_requantize(symbol)" args =>
-                      String ->
-                        ArgsHMap "_contrib_requantize(symbol)" args -> IO SymbolHandle
-_contrib_requantize name args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])),
-               ("min_calib_range",) . showValue <$>
-                 (args !? #min_calib_range :: Maybe (Maybe Float)),
-               ("max_calib_range",) . showValue <$>
-                 (args !? #max_calib_range :: Maybe (Maybe Float))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_requantize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantized_act(symbol)" =
-     '[ '("act_type",
-          AttrReq
-            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),
-        '("data", AttrOpt SymbolHandle),
-        '("min_data", AttrOpt SymbolHandle),
-        '("max_data", AttrOpt SymbolHandle)]
-
-_contrib_quantized_act ::
-                       forall args . Fullfilled "_contrib_quantized_act(symbol)" args =>
-                         String ->
-                           ArgsHMap "_contrib_quantized_act(symbol)" args -> IO SymbolHandle
-_contrib_quantized_act name args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_data",) <$> (args !? #min_data :: Maybe SymbolHandle),
-               ("max_data",) <$> (args !? #max_data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantized_act"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_quantize(symbol)" =
-     '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])),
-        '("data", AttrOpt SymbolHandle),
-        '("min_range", AttrOpt SymbolHandle),
-        '("max_range", AttrOpt SymbolHandle)]
-
-_contrib_quantize ::
-                  forall args . Fullfilled "_contrib_quantize(symbol)" args =>
-                    String ->
-                      ArgsHMap "_contrib_quantize(symbol)" args -> IO SymbolHandle
-_contrib_quantize name args
-  = let scalarArgs
-          = catMaybes
-              [("out_type",) . showValue <$>
-                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("min_range",) <$> (args !? #min_range :: Maybe SymbolHandle),
-               ("max_range",) <$> (args !? #max_range :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_quantize"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_cvimread(symbol)" =
-     '[ '("filename", AttrReq String), '("flag", AttrOpt Int),
-        '("to_rgb", AttrOpt Bool)]
-
-_cvimread ::
-          forall args . Fullfilled "_cvimread(symbol)" args =>
-            String -> ArgsHMap "_cvimread(symbol)" args -> IO SymbolHandle
-_cvimread name args
-  = let scalarArgs
-          = catMaybes
-              [("filename",) . showValue <$> (args !? #filename :: Maybe String),
-               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),
-               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_cvimread"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_NoGradient(symbol)" = '[]
-
-_NoGradient ::
-            forall args . Fullfilled "_NoGradient(symbol)" args =>
-              String -> ArgsHMap "_NoGradient(symbol)" args -> IO SymbolHandle
-_NoGradient name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_NoGradient"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CachedOp(symbol)" =
-     '[ '("data", AttrOpt [SymbolHandle])]
-
-_CachedOp ::
-          forall args . Fullfilled "_CachedOp(symbol)" args =>
-            String -> ArgsHMap "_CachedOp(symbol)" args -> IO SymbolHandle
-_CachedOp name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "_CachedOp"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_CachedOp(symbol)" = '[]
-
-_backward_CachedOp ::
-                   forall args . Fullfilled "_backward_CachedOp(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_CachedOp(symbol)" args -> IO SymbolHandle
-_backward_CachedOp name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CachedOp"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "softmax_cross_entropy(symbol)" =
-     '[ '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-softmax_cross_entropy ::
-                      forall args . Fullfilled "softmax_cross_entropy(symbol)" args =>
-                        String ->
-                          ArgsHMap "softmax_cross_entropy(symbol)" args -> IO SymbolHandle
-softmax_cross_entropy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "softmax_cross_entropy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_softmax_cross_entropy(symbol)" = '[]
-
-_backward_softmax_cross_entropy ::
-                                forall args .
-                                  Fullfilled "_backward_softmax_cross_entropy(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_backward_softmax_cross_entropy(symbol)" args ->
-                                      IO SymbolHandle
-_backward_softmax_cross_entropy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_softmax_cross_entropy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_foreach(symbol)" = '[]
-
-_backward_foreach ::
-                  forall args . Fullfilled "_backward_foreach(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward_foreach(symbol)" args -> IO SymbolHandle
-_backward_foreach name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_foreach"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_while_loop(symbol)" = '[]
-
-_backward_while_loop ::
-                     forall args . Fullfilled "_backward_while_loop(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_while_loop(symbol)" args -> IO SymbolHandle
-_backward_while_loop name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_while_loop"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_cond(symbol)" = '[]
-
-_backward_cond ::
-               forall args . Fullfilled "_backward_cond(symbol)" args =>
-                 String -> ArgsHMap "_backward_cond(symbol)" args -> IO SymbolHandle
-_backward_cond name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_cond"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SoftmaxOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
-        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle), '("label", AttrOpt SymbolHandle)]
-
-_SoftmaxOutput ::
-               forall args . Fullfilled "_SoftmaxOutput(symbol)" args =>
-                 String -> ArgsHMap "_SoftmaxOutput(symbol)" args -> IO SymbolHandle
-_SoftmaxOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("multi_output",) . showValue <$>
-                 (args !? #multi_output :: Maybe Bool),
-               ("use_ignore",) . showValue <$>
-                 (args !? #use_ignore :: Maybe Bool),
-               ("preserve_shape",) . showValue <$>
-                 (args !? #preserve_shape :: Maybe Bool),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"])),
-               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
-               ("smooth_alpha",) . showValue <$>
-                 (args !? #smooth_alpha :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SoftmaxOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SoftmaxOutput(symbol)" = '[]
-
-_backward_SoftmaxOutput ::
-                        forall args . Fullfilled "_backward_SoftmaxOutput(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_SoftmaxOutput(symbol)" args -> IO SymbolHandle
-_backward_SoftmaxOutput name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SoftmaxOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LeakyReLU(symbol)" =
-     '[ '("act_type",
-          AttrOpt
-            (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])),
-        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),
-        '("upper_bound", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle)]
-
-_LeakyReLU ::
-           forall args . Fullfilled "_LeakyReLU(symbol)" args =>
-             String -> ArgsHMap "_LeakyReLU(symbol)" args -> IO SymbolHandle
-_LeakyReLU name args
-  = let scalarArgs
-          = catMaybes
-              [("act_type",) . showValue <$>
-                 (args !? #act_type ::
-                    Maybe
-                      (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])),
-               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),
-               ("lower_bound",) . showValue <$>
-                 (args !? #lower_bound :: Maybe Float),
-               ("upper_bound",) . showValue <$>
-                 (args !? #upper_bound :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LeakyReLU"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SwapAxis(symbol)" =
-     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle)]
-
-_SwapAxis ::
-          forall args . Fullfilled "_SwapAxis(symbol)" args =>
-            String -> ArgsHMap "_SwapAxis(symbol)" args -> IO SymbolHandle
-_SwapAxis name args
-  = let scalarArgs
-          = catMaybes
-              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),
-               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SwapAxis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_IdentityAttachKLSparseReg(symbol)" =
-     '[ '("sparseness_target", AttrOpt Float),
-        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("data", AttrOpt SymbolHandle)]
-
-_IdentityAttachKLSparseReg ::
-                           forall args .
-                             Fullfilled "_IdentityAttachKLSparseReg(symbol)" args =>
-                             String ->
-                               ArgsHMap "_IdentityAttachKLSparseReg(symbol)" args ->
-                                 IO SymbolHandle
-_IdentityAttachKLSparseReg name args
-  = let scalarArgs
-          = catMaybes
-              [("sparseness_target",) . showValue <$>
-                 (args !? #sparseness_target :: Maybe Float),
-               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "IdentityAttachKLSparseReg"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SliceChannel(symbol)" =
-     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),
-        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt SymbolHandle)]
-
-_SliceChannel ::
-              forall args . Fullfilled "_SliceChannel(symbol)" args =>
-                String -> ArgsHMap "_SliceChannel(symbol)" args -> IO SymbolHandle
-_SliceChannel name args
-  = let scalarArgs
-          = catMaybes
-              [("num_outputs",) . showValue <$>
-                 (args !? #num_outputs :: Maybe Int),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
-               ("squeeze_axis",) . showValue <$>
-                 (args !? #squeeze_axis :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SliceChannel"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_RNN(symbol)" =
-     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),
-        '("bidirectional", AttrOpt Bool),
-        '("mode",
-          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),
-        '("projection_size", AttrOpt (Maybe Int)),
-        '("lstm_state_clip_min", AttrOpt (Maybe Double)),
-        '("lstm_state_clip_max", AttrOpt (Maybe Double)),
-        '("lstm_state_clip_nan", AttrOpt Bool),
-        '("use_sequence_length", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle),
-        '("parameters", AttrOpt SymbolHandle),
-        '("state", AttrOpt SymbolHandle),
-        '("state_cell", AttrOpt SymbolHandle),
-        '("sequence_length", AttrOpt SymbolHandle)]
-
-_RNN ::
-     forall args . Fullfilled "_RNN(symbol)" args =>
-       String -> ArgsHMap "_RNN(symbol)" args -> IO SymbolHandle
-_RNN name args
-  = let scalarArgs
-          = catMaybes
-              [("state_size",) . showValue <$>
-                 (args !? #state_size :: Maybe Int),
-               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),
-               ("bidirectional",) . showValue <$>
-                 (args !? #bidirectional :: Maybe Bool),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
-               ("p",) . showValue <$> (args !? #p :: Maybe Float),
-               ("state_outputs",) . showValue <$>
-                 (args !? #state_outputs :: Maybe Bool),
-               ("projection_size",) . showValue <$>
-                 (args !? #projection_size :: Maybe (Maybe Int)),
-               ("lstm_state_clip_min",) . showValue <$>
-                 (args !? #lstm_state_clip_min :: Maybe (Maybe Double)),
-               ("lstm_state_clip_max",) . showValue <$>
-                 (args !? #lstm_state_clip_max :: Maybe (Maybe Double)),
-               ("lstm_state_clip_nan",) . showValue <$>
-                 (args !? #lstm_state_clip_nan :: Maybe Bool),
-               ("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("parameters",) <$> (args !? #parameters :: Maybe SymbolHandle),
-               ("state",) <$> (args !? #state :: Maybe SymbolHandle),
-               ("state_cell",) <$> (args !? #state_cell :: Maybe SymbolHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "RNN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_RNN(symbol)" = '[]
-
-_backward_RNN ::
-              forall args . Fullfilled "_backward_RNN(symbol)" args =>
-                String -> ArgsHMap "_backward_RNN(symbol)" args -> IO SymbolHandle
-_backward_RNN name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_RNN"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Pad(symbol)" =
-     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),
-        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),
-        '("data", AttrOpt SymbolHandle)]
-
-_Pad ::
-     forall args . Fullfilled "_Pad(symbol)" args =>
-       String -> ArgsHMap "_Pad(symbol)" args -> IO SymbolHandle
-_Pad name args
-  = let scalarArgs
-          = catMaybes
-              [("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["constant", "edge", "reflect"])),
-               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),
-               ("constant_value",) . showValue <$>
-                 (args !? #constant_value :: Maybe Double)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pad"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BatchNorm_v1(symbol)" =
-     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
-        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
-        '("output_mean_var", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle), '("gamma", AttrOpt SymbolHandle),
-        '("beta", AttrOpt SymbolHandle)]
-
-_BatchNorm_v1 ::
-              forall args . Fullfilled "_BatchNorm_v1(symbol)" args =>
-                String -> ArgsHMap "_BatchNorm_v1(symbol)" args -> IO SymbolHandle
-_BatchNorm_v1 name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
-               ("use_global_stats",) . showValue <$>
-                 (args !? #use_global_stats :: Maybe Bool),
-               ("output_mean_var",) . showValue <$>
-                 (args !? #output_mean_var :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BatchNorm_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "signsgd_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)]
-
-signsgd_update ::
-               forall args . Fullfilled "signsgd_update(symbol)" args =>
-                 String -> ArgsHMap "signsgd_update(symbol)" args -> IO SymbolHandle
-signsgd_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signsgd_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "signum_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mom", AttrOpt SymbolHandle)]
-
-signum_update ::
-              forall args . Fullfilled "signum_update(symbol)" args =>
-                String -> ArgsHMap "signum_update(symbol)" args -> IO SymbolHandle
-signum_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "signum_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "multi_sgd_update(symbol)" =
-     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-multi_sgd_update ::
-                 forall args . Fullfilled "multi_sgd_update(symbol)" args =>
-                   String ->
-                     ArgsHMap "multi_sgd_update(symbol)" args -> IO SymbolHandle
-multi_sgd_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
-               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("num_weights",) . showValue <$>
-                 (args !? #num_weights :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "multi_sgd_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "multi_sgd_mom_update(symbol)" =
-     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),
-        '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-multi_sgd_mom_update ::
-                     forall args . Fullfilled "multi_sgd_mom_update(symbol)" args =>
-                       String ->
-                         ArgsHMap "multi_sgd_mom_update(symbol)" args -> IO SymbolHandle
-multi_sgd_mom_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
-               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("num_weights",) . showValue <$>
-                 (args !? #num_weights :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "multi_sgd_mom_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "multi_mp_sgd_update(symbol)" =
-     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-multi_mp_sgd_update ::
-                    forall args . Fullfilled "multi_mp_sgd_update(symbol)" args =>
-                      String ->
-                        ArgsHMap "multi_mp_sgd_update(symbol)" args -> IO SymbolHandle
-multi_mp_sgd_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
-               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("num_weights",) . showValue <$>
-                 (args !? #num_weights :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "multi_mp_sgd_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "multi_mp_sgd_mom_update(symbol)" =
-     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),
-        '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
-        '("data", AttrOpt [SymbolHandle])]
-
-multi_mp_sgd_mom_update ::
-                        forall args . Fullfilled "multi_mp_sgd_mom_update(symbol)" args =>
-                          String ->
-                            ArgsHMap "multi_mp_sgd_mom_update(symbol)" args -> IO SymbolHandle
-multi_mp_sgd_mom_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
-               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("num_weights",) . showValue <$>
-                 (args !? #num_weights :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "multi_mp_sgd_mom_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "sgd_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle)]
-
-sgd_update ::
-           forall args . Fullfilled "sgd_update(symbol)" args =>
-             String -> ArgsHMap "sgd_update(symbol)" args -> IO SymbolHandle
-sgd_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "sgd_mom_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mom", AttrOpt SymbolHandle)]
-
-sgd_mom_update ::
-               forall args . Fullfilled "sgd_mom_update(symbol)" args =>
-                 String -> ArgsHMap "sgd_mom_update(symbol)" args -> IO SymbolHandle
-sgd_mom_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "sgd_mom_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "mp_sgd_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("weight32", AttrOpt SymbolHandle)]
-
-mp_sgd_update ::
-              forall args . Fullfilled "mp_sgd_update(symbol)" args =>
-                String -> ArgsHMap "mp_sgd_update(symbol)" args -> IO SymbolHandle
-mp_sgd_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "mp_sgd_mom_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mom", AttrOpt SymbolHandle),
-        '("weight32", AttrOpt SymbolHandle)]
-
-mp_sgd_mom_update ::
-                  forall args . Fullfilled "mp_sgd_mom_update(symbol)" args =>
-                    String ->
-                      ArgsHMap "mp_sgd_mom_update(symbol)" args -> IO SymbolHandle
-mp_sgd_mom_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_sgd_mom_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ftml_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double),
-        '("t", AttrReq Int), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("d", AttrOpt SymbolHandle), '("v", AttrOpt SymbolHandle),
-        '("z", AttrOpt SymbolHandle)]
-
-ftml_update ::
-            forall args . Fullfilled "ftml_update(symbol)" args =>
-              String -> ArgsHMap "ftml_update(symbol)" args -> IO SymbolHandle
-ftml_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),
-               ("t",) . showValue <$> (args !? #t :: Maybe Int),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("d",) <$> (args !? #d :: Maybe SymbolHandle),
-               ("v",) <$> (args !? #v :: Maybe SymbolHandle),
-               ("z",) <$> (args !? #z :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftml_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "adam_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
-        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mean", AttrOpt SymbolHandle), '("var", AttrOpt SymbolHandle)]
-
-adam_update ::
-            forall args . Fullfilled "adam_update(symbol)" args =>
-              String -> ArgsHMap "adam_update(symbol)" args -> IO SymbolHandle
-adam_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
-               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("lazy_update",) . showValue <$>
-                 (args !? #lazy_update :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mean",) <$> (args !? #mean :: Maybe SymbolHandle),
-               ("var",) <$> (args !? #var :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "adam_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "nag_mom_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mom", AttrOpt SymbolHandle)]
-
-nag_mom_update ::
-               forall args . Fullfilled "nag_mom_update(symbol)" args =>
-                 String -> ArgsHMap "nag_mom_update(symbol)" args -> IO SymbolHandle
-nag_mom_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "nag_mom_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "mp_nag_mom_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("mom", AttrOpt SymbolHandle),
-        '("weight32", AttrOpt SymbolHandle)]
-
-mp_nag_mom_update ::
-                  forall args . Fullfilled "mp_nag_mom_update(symbol)" args =>
-                    String ->
-                      ArgsHMap "mp_nag_mom_update(symbol)" args -> IO SymbolHandle
-mp_nag_mom_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("mom",) <$> (args !? #mom :: Maybe SymbolHandle),
-               ("weight32",) <$> (args !? #weight32 :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "mp_nag_mom_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rmsprop_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("n", AttrOpt SymbolHandle)]
-
-rmsprop_update ::
-               forall args . Fullfilled "rmsprop_update(symbol)" args =>
-                 String -> ArgsHMap "rmsprop_update(symbol)" args -> IO SymbolHandle
-rmsprop_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmsprop_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "rmspropalex_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
-        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("clip_weights", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("n", AttrOpt SymbolHandle), '("g", AttrOpt SymbolHandle),
-        '("delta", AttrOpt SymbolHandle)]
-
-rmspropalex_update ::
-                   forall args . Fullfilled "rmspropalex_update(symbol)" args =>
-                     String ->
-                       ArgsHMap "rmspropalex_update(symbol)" args -> IO SymbolHandle
-rmspropalex_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
-               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float),
-               ("clip_weights",) . showValue <$>
-                 (args !? #clip_weights :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("n",) <$> (args !? #n :: Maybe SymbolHandle),
-               ("g",) <$> (args !? #g :: Maybe SymbolHandle),
-               ("delta",) <$> (args !? #delta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "rmspropalex_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "ftrl_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),
-        '("beta", AttrOpt Float), '("wd", AttrOpt Float),
-        '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("z", AttrOpt SymbolHandle), '("n", AttrOpt SymbolHandle)]
-
-ftrl_update ::
-            forall args . Fullfilled "ftrl_update(symbol)" args =>
-              String -> ArgsHMap "ftrl_update(symbol)" args -> IO SymbolHandle
-ftrl_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),
-               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("z",) <$> (args !? #z :: Maybe SymbolHandle),
-               ("n",) <$> (args !? #n :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ftrl_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_sparse_adagrad_update(symbol)" =
-     '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float),
-        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
-        '("clip_gradient", AttrOpt Float),
-        '("weight", AttrOpt SymbolHandle), '("grad", AttrOpt SymbolHandle),
-        '("history", AttrOpt SymbolHandle)]
-
-_sparse_adagrad_update ::
-                       forall args . Fullfilled "_sparse_adagrad_update(symbol)" args =>
-                         String ->
-                           ArgsHMap "_sparse_adagrad_update(symbol)" args -> IO SymbolHandle
-_sparse_adagrad_update name args
-  = let scalarArgs
-          = catMaybes
-              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
-               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
-               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
-               ("rescale_grad",) . showValue <$>
-                 (args !? #rescale_grad :: Maybe Float),
-               ("clip_gradient",) . showValue <$>
-                 (args !? #clip_gradient :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("grad",) <$> (args !? #grad :: Maybe SymbolHandle),
-               ("history",) <$> (args !? #history :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_sparse_adagrad_update"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LinearRegressionOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_LinearRegressionOutput ::
-                        forall args . Fullfilled "_LinearRegressionOutput(symbol)" args =>
-                          String ->
-                            ArgsHMap "_LinearRegressionOutput(symbol)" args -> IO SymbolHandle
-_LinearRegressionOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LinearRegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_linear_reg_out(symbol)" =
-     '[]
-
-_backward_linear_reg_out ::
-                         forall args . Fullfilled "_backward_linear_reg_out(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_linear_reg_out(symbol)" args -> IO SymbolHandle
-_backward_linear_reg_out name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_linear_reg_out"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_MAERegressionOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_MAERegressionOutput ::
-                     forall args . Fullfilled "_MAERegressionOutput(symbol)" args =>
-                       String ->
-                         ArgsHMap "_MAERegressionOutput(symbol)" args -> IO SymbolHandle
-_MAERegressionOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MAERegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_mae_reg_out(symbol)" = '[]
-
-_backward_mae_reg_out ::
-                      forall args . Fullfilled "_backward_mae_reg_out(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_mae_reg_out(symbol)" args -> IO SymbolHandle
-_backward_mae_reg_out name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_mae_reg_out"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_LogisticRegressionOutput(symbol)" =
-     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_LogisticRegressionOutput ::
-                          forall args .
-                            Fullfilled "_LogisticRegressionOutput(symbol)" args =>
-                            String ->
-                              ArgsHMap "_LogisticRegressionOutput(symbol)" args ->
-                                IO SymbolHandle
-_LogisticRegressionOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "LogisticRegressionOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_logistic_reg_out(symbol)" =
-     '[]
-
-_backward_logistic_reg_out ::
-                           forall args .
-                             Fullfilled "_backward_logistic_reg_out(symbol)" args =>
-                             String ->
-                               ArgsHMap "_backward_logistic_reg_out(symbol)" args ->
-                                 IO SymbolHandle
-_backward_logistic_reg_out name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_logistic_reg_out"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CustomFunction(symbol)" = '[]
-
-_CustomFunction ::
-                forall args . Fullfilled "_CustomFunction(symbol)" args =>
-                  String ->
-                    ArgsHMap "_CustomFunction(symbol)" args -> IO SymbolHandle
-_CustomFunction name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CustomFunction"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_CustomFunction(symbol)" =
-     '[]
-
-_backward_CustomFunction ::
-                         forall args . Fullfilled "_backward_CustomFunction(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_CustomFunction(symbol)" args -> IO SymbolHandle
-_backward_CustomFunction name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_CustomFunction"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__Native(symbol)" = '[]
-
-_backward__Native ::
-                  forall args . Fullfilled "_backward__Native(symbol)" args =>
-                    String ->
-                      ArgsHMap "_backward__Native(symbol)" args -> IO SymbolHandle
-_backward__Native name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__Native"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__NDArray(symbol)" = '[]
-
-_backward__NDArray ::
-                   forall args . Fullfilled "_backward__NDArray(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward__NDArray(symbol)" args -> IO SymbolHandle
-_backward__NDArray name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__NDArray"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiBoxTarget(symbol)" =
-     '[ '("overlap_threshold", AttrOpt Float),
-        '("ignore_label", AttrOpt Float),
-        '("negative_mining_ratio", AttrOpt Float),
-        '("negative_mining_thresh", AttrOpt Float),
-        '("minimum_negative_samples", AttrOpt Int),
-        '("variances", AttrOpt [Float]), '("anchor", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle),
-        '("cls_pred", AttrOpt SymbolHandle)]
-
-_contrib_MultiBoxTarget ::
-                        forall args . Fullfilled "_contrib_MultiBoxTarget(symbol)" args =>
-                          String ->
-                            ArgsHMap "_contrib_MultiBoxTarget(symbol)" args -> IO SymbolHandle
-_contrib_MultiBoxTarget name args
-  = let scalarArgs
-          = catMaybes
-              [("overlap_threshold",) . showValue <$>
-                 (args !? #overlap_threshold :: Maybe Float),
-               ("ignore_label",) . showValue <$>
-                 (args !? #ignore_label :: Maybe Float),
-               ("negative_mining_ratio",) . showValue <$>
-                 (args !? #negative_mining_ratio :: Maybe Float),
-               ("negative_mining_thresh",) . showValue <$>
-                 (args !? #negative_mining_thresh :: Maybe Float),
-               ("minimum_negative_samples",) . showValue <$>
-                 (args !? #minimum_negative_samples :: Maybe Int),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle),
-               ("cls_pred",) <$> (args !? #cls_pred :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxTarget"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxTarget(symbol)" = '[]
-
-_backward__contrib_MultiBoxTarget ::
-                                  forall args .
-                                    Fullfilled "_backward__contrib_MultiBoxTarget(symbol)" args =>
-                                    String ->
-                                      ArgsHMap "_backward__contrib_MultiBoxTarget(symbol)" args ->
-                                        IO SymbolHandle
-_backward__contrib_MultiBoxTarget name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxTarget"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_Proposal(symbol)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle),
-        '("bbox_pred", AttrOpt SymbolHandle),
-        '("im_info", AttrOpt SymbolHandle)]
-
-_contrib_Proposal ::
-                  forall args . Fullfilled "_contrib_Proposal(symbol)" args =>
-                    String ->
-                      ArgsHMap "_contrib_Proposal(symbol)" args -> IO SymbolHandle
-_contrib_Proposal name args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_Proposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__contrib_Proposal(symbol)" =
-     '[]
-
-_backward__contrib_Proposal ::
-                            forall args .
-                              Fullfilled "_backward__contrib_Proposal(symbol)" args =>
-                              String ->
-                                ArgsHMap "_backward__contrib_Proposal(symbol)" args ->
-                                  IO SymbolHandle
-_backward__contrib_Proposal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_Proposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_count_sketch(symbol)" =
-     '[ '("out_dim", AttrReq Int),
-        '("processing_batch_size", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle), '("h", AttrOpt SymbolHandle),
-        '("s", AttrOpt SymbolHandle)]
-
-_contrib_count_sketch ::
-                      forall args . Fullfilled "_contrib_count_sketch(symbol)" args =>
-                        String ->
-                          ArgsHMap "_contrib_count_sketch(symbol)" args -> IO SymbolHandle
-_contrib_count_sketch name args
-  = let scalarArgs
-          = catMaybes
-              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),
-               ("processing_batch_size",) . showValue <$>
-                 (args !? #processing_batch_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("h",) <$> (args !? #h :: Maybe SymbolHandle),
-               ("s",) <$> (args !? #s :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_count_sketch"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_count_sketch(symbol)" = '[]
-
-_backward__contrib_count_sketch ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_count_sketch(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_backward__contrib_count_sketch(symbol)" args ->
-                                      IO SymbolHandle
-_backward__contrib_count_sketch name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_count_sketch"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiBoxDetection(symbol)" =
-     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),
-        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),
-        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),
-        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt SymbolHandle),
-        '("loc_pred", AttrOpt SymbolHandle),
-        '("anchor", AttrOpt SymbolHandle)]
-
-_contrib_MultiBoxDetection ::
-                           forall args .
-                             Fullfilled "_contrib_MultiBoxDetection(symbol)" args =>
-                             String ->
-                               ArgsHMap "_contrib_MultiBoxDetection(symbol)" args ->
-                                 IO SymbolHandle
-_contrib_MultiBoxDetection name args
-  = let scalarArgs
-          = catMaybes
-              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("background_id",) . showValue <$>
-                 (args !? #background_id :: Maybe Int),
-               ("nms_threshold",) . showValue <$>
-                 (args !? #nms_threshold :: Maybe Float),
-               ("force_suppress",) . showValue <$>
-                 (args !? #force_suppress :: Maybe Bool),
-               ("variances",) . showValue <$>
-                 (args !? #variances :: Maybe [Float]),
-               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),
-               ("loc_pred",) <$> (args !? #loc_pred :: Maybe SymbolHandle),
-               ("anchor",) <$> (args !? #anchor :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxDetection"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxDetection(symbol)" = '[]
-
-_backward__contrib_MultiBoxDetection ::
-                                     forall args .
-                                       Fullfilled "_backward__contrib_MultiBoxDetection(symbol)"
-                                         args =>
-                                       String ->
-                                         ArgsHMap "_backward__contrib_MultiBoxDetection(symbol)"
-                                           args
-                                           -> IO SymbolHandle
-_backward__contrib_MultiBoxDetection name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxDetection"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_contrib_DeformablePSROIPooling(symbol)" =
-     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),
-        '("group_size", AttrReq Int), '("pooled_size", AttrReq Int),
-        '("part_size", AttrOpt Int), '("sample_per_part", AttrOpt Int),
-        '("trans_std", AttrOpt Float), '("no_trans", AttrOpt Bool),
-        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle),
-        '("trans", AttrOpt SymbolHandle)]
-
-_contrib_DeformablePSROIPooling ::
-                                forall args .
-                                  Fullfilled "_contrib_DeformablePSROIPooling(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_contrib_DeformablePSROIPooling(symbol)" args ->
-                                      IO SymbolHandle
-_contrib_DeformablePSROIPooling name args
-  = let scalarArgs
-          = catMaybes
-              [("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int),
-               ("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe Int),
-               ("part_size",) . showValue <$> (args !? #part_size :: Maybe Int),
-               ("sample_per_part",) . showValue <$>
-                 (args !? #sample_per_part :: Maybe Int),
-               ("trans_std",) . showValue <$> (args !? #trans_std :: Maybe Float),
-               ("no_trans",) . showValue <$> (args !? #no_trans :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle),
-               ("trans",) <$> (args !? #trans :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformablePSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_DeformablePSROIPooling(symbol)" =
-     '[]
-
-_backward__contrib_DeformablePSROIPooling ::
-                                          forall args .
-                                            Fullfilled
-                                              "_backward__contrib_DeformablePSROIPooling(symbol)"
-                                              args =>
-                                            String ->
-                                              ArgsHMap
-                                                "_backward__contrib_DeformablePSROIPooling(symbol)"
-                                                args
-                                                -> IO SymbolHandle
-_backward__contrib_DeformablePSROIPooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformablePSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_fft(symbol)" =
-     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-_contrib_fft ::
-             forall args . Fullfilled "_contrib_fft(symbol)" args =>
-               String -> ArgsHMap "_contrib_fft(symbol)" args -> IO SymbolHandle
-_contrib_fft name args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_fft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__contrib_fft(symbol)" = '[]
-
-_backward__contrib_fft ::
-                       forall args . Fullfilled "_backward__contrib_fft(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward__contrib_fft(symbol)" args -> IO SymbolHandle
-_backward__contrib_fft name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_fft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiBoxPrior(symbol)" =
-     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),
-        '("offsets", AttrOpt [Float]), '("data", AttrOpt SymbolHandle)]
-
-_contrib_MultiBoxPrior ::
-                       forall args . Fullfilled "_contrib_MultiBoxPrior(symbol)" args =>
-                         String ->
-                           ArgsHMap "_contrib_MultiBoxPrior(symbol)" args -> IO SymbolHandle
-_contrib_MultiBoxPrior name args
-  = let scalarArgs
-          = catMaybes
-              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
-               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),
-               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiBoxPrior"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiBoxPrior(symbol)" = '[]
-
-_backward__contrib_MultiBoxPrior ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiBoxPrior(symbol)" args =>
-                                   String ->
-                                     ArgsHMap "_backward__contrib_MultiBoxPrior(symbol)" args ->
-                                       IO SymbolHandle
-_backward__contrib_MultiBoxPrior name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiBoxPrior"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_MultiProposal(symbol)" =
-     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
-        '("rpn_post_nms_top_n", AttrOpt Int),
-        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
-        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
-        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
-        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt SymbolHandle),
-        '("bbox_pred", AttrOpt SymbolHandle),
-        '("im_info", AttrOpt SymbolHandle)]
-
-_contrib_MultiProposal ::
-                       forall args . Fullfilled "_contrib_MultiProposal(symbol)" args =>
-                         String ->
-                           ArgsHMap "_contrib_MultiProposal(symbol)" args -> IO SymbolHandle
-_contrib_MultiProposal name args
-  = let scalarArgs
-          = catMaybes
-              [("rpn_pre_nms_top_n",) . showValue <$>
-                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
-               ("rpn_post_nms_top_n",) . showValue <$>
-                 (args !? #rpn_post_nms_top_n :: Maybe Int),
-               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
-               ("rpn_min_size",) . showValue <$>
-                 (args !? #rpn_min_size :: Maybe Int),
-               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
-               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
-               ("feature_stride",) . showValue <$>
-                 (args !? #feature_stride :: Maybe Int),
-               ("output_score",) . showValue <$>
-                 (args !? #output_score :: Maybe Bool),
-               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("cls_prob",) <$> (args !? #cls_prob :: Maybe SymbolHandle),
-               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe SymbolHandle),
-               ("im_info",) <$> (args !? #im_info :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_MultiProposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_MultiProposal(symbol)" = '[]
-
-_backward__contrib_MultiProposal ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_MultiProposal(symbol)" args =>
-                                   String ->
-                                     ArgsHMap "_backward__contrib_MultiProposal(symbol)" args ->
-                                       IO SymbolHandle
-_backward__contrib_MultiProposal name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_MultiProposal"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_PSROIPooling(symbol)" =
-     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),
-        '("pooled_size", AttrReq Int), '("group_size", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle), '("rois", AttrOpt SymbolHandle)]
-
-_contrib_PSROIPooling ::
-                      forall args . Fullfilled "_contrib_PSROIPooling(symbol)" args =>
-                        String ->
-                          ArgsHMap "_contrib_PSROIPooling(symbol)" args -> IO SymbolHandle
-_contrib_PSROIPooling name args
-  = let scalarArgs
-          = catMaybes
-              [("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float),
-               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
-               ("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe Int),
-               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_PSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_PSROIPooling(symbol)" = '[]
-
-_backward__contrib_PSROIPooling ::
-                                forall args .
-                                  Fullfilled "_backward__contrib_PSROIPooling(symbol)" args =>
-                                  String ->
-                                    ArgsHMap "_backward__contrib_PSROIPooling(symbol)" args ->
-                                      IO SymbolHandle
-_backward__contrib_PSROIPooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_PSROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_contrib_DeformableConvolution(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("num_deformable_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),
-        '("data", AttrOpt SymbolHandle), '("offset", AttrOpt SymbolHandle),
-        '("weight", AttrOpt SymbolHandle), '("bias", AttrOpt SymbolHandle)]
-
-_contrib_DeformableConvolution ::
-                               forall args .
-                                 Fullfilled "_contrib_DeformableConvolution(symbol)" args =>
-                                 String ->
-                                   ArgsHMap "_contrib_DeformableConvolution(symbol)" args ->
-                                     IO SymbolHandle
-_contrib_DeformableConvolution name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("num_deformable_group",) . showValue <$>
-                 (args !? #num_deformable_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("offset",) <$> (args !? #offset :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_DeformableConvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_DeformableConvolution(symbol)" =
-     '[]
-
-_backward__contrib_DeformableConvolution ::
-                                         forall args .
-                                           Fullfilled
-                                             "_backward__contrib_DeformableConvolution(symbol)"
-                                             args =>
-                                           String ->
-                                             ArgsHMap
-                                               "_backward__contrib_DeformableConvolution(symbol)"
-                                               args
-                                               -> IO SymbolHandle
-_backward__contrib_DeformableConvolution name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_DeformableConvolution"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_contrib_ifft(symbol)" =
-     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt SymbolHandle)]
-
-_contrib_ifft ::
-              forall args . Fullfilled "_contrib_ifft(symbol)" args =>
-                String -> ArgsHMap "_contrib_ifft(symbol)" args -> IO SymbolHandle
-_contrib_ifft name args
-  = let scalarArgs
-          = catMaybes
-              [("compute_size",) . showValue <$>
-                 (args !? #compute_size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_contrib_ifft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__contrib_ifft(symbol)" = '[]
-
-_backward__contrib_ifft ::
-                        forall args . Fullfilled "_backward__contrib_ifft(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward__contrib_ifft(symbol)" args -> IO SymbolHandle
-_backward__contrib_ifft name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_ifft"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward__contrib_SyncBatchNorm(symbol)" = '[]
-
-_backward__contrib_SyncBatchNorm ::
-                                 forall args .
-                                   Fullfilled "_backward__contrib_SyncBatchNorm(symbol)" args =>
-                                   String ->
-                                     ArgsHMap "_backward__contrib_SyncBatchNorm(symbol)" args ->
-                                       IO SymbolHandle
-_backward__contrib_SyncBatchNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__contrib_SyncBatchNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_InstanceNorm(symbol)" =
-     '[ '("eps", AttrOpt Float), '("data", AttrOpt SymbolHandle),
-        '("gamma", AttrOpt SymbolHandle), '("beta", AttrOpt SymbolHandle)]
-
-_InstanceNorm ::
-              forall args . Fullfilled "_InstanceNorm(symbol)" args =>
-                String -> ArgsHMap "_InstanceNorm(symbol)" args -> IO SymbolHandle
-_InstanceNorm name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("gamma",) <$> (args !? #gamma :: Maybe SymbolHandle),
-               ("beta",) <$> (args !? #beta :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "InstanceNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_InstanceNorm(symbol)" = '[]
-
-_backward_InstanceNorm ::
-                       forall args . Fullfilled "_backward_InstanceNorm(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_InstanceNorm(symbol)" args -> IO SymbolHandle
-_backward_InstanceNorm name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_InstanceNorm"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SVMOutput(symbol)" =
-     '[ '("margin", AttrOpt Float),
-        '("regularization_coefficient", AttrOpt Float),
-        '("use_linear", AttrOpt Bool), '("data", AttrOpt SymbolHandle),
-        '("label", AttrOpt SymbolHandle)]
-
-_SVMOutput ::
-           forall args . Fullfilled "_SVMOutput(symbol)" args =>
-             String -> ArgsHMap "_SVMOutput(symbol)" args -> IO SymbolHandle
-_SVMOutput name args
-  = let scalarArgs
-          = catMaybes
-              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),
-               ("regularization_coefficient",) . showValue <$>
-                 (args !? #regularization_coefficient :: Maybe Float),
-               ("use_linear",) . showValue <$>
-                 (args !? #use_linear :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("label",) <$> (args !? #label :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SVMOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SVMOutput(symbol)" = '[]
-
-_backward_SVMOutput ::
-                    forall args . Fullfilled "_backward_SVMOutput(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_SVMOutput(symbol)" args -> IO SymbolHandle
-_backward_SVMOutput name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SVMOutput"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_GridGenerator(symbol)" =
-     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),
-        '("target_shape", AttrOpt [Int]), '("data", AttrOpt SymbolHandle)]
-
-_GridGenerator ::
-               forall args . Fullfilled "_GridGenerator(symbol)" args =>
-                 String -> ArgsHMap "_GridGenerator(symbol)" args -> IO SymbolHandle
-_GridGenerator name args
-  = let scalarArgs
-          = catMaybes
-              [("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),
-               ("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "GridGenerator"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_GridGenerator(symbol)" = '[]
-
-_backward_GridGenerator ::
-                        forall args . Fullfilled "_backward_GridGenerator(symbol)" args =>
-                          String ->
-                            ArgsHMap "_backward_GridGenerator(symbol)" args -> IO SymbolHandle
-_backward_GridGenerator name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_GridGenerator"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Convolution_v1(symbol)" =
-     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
-        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
-        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
-        '("cudnn_tune",
-          AttrOpt
-            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-        '("cudnn_off", AttrOpt Bool),
-        '("layout",
-          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),
-        '("data", AttrOpt SymbolHandle), '("weight", AttrOpt SymbolHandle),
-        '("bias", AttrOpt SymbolHandle)]
-
-_Convolution_v1 ::
-                forall args . Fullfilled "_Convolution_v1(symbol)" args =>
-                  String ->
-                    ArgsHMap "_Convolution_v1(symbol)" args -> IO SymbolHandle
-_Convolution_v1 name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
-               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
-               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
-               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
-               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
-               ("cudnn_tune",) . showValue <$>
-                 (args !? #cudnn_tune ::
-                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
-               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
-               ("layout",) . showValue <$>
-                 (args !? #layout ::
-                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("weight",) <$> (args !? #weight :: Maybe SymbolHandle),
-               ("bias",) <$> (args !? #bias :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Convolution_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Convolution_v1(symbol)" =
-     '[]
-
-_backward_Convolution_v1 ::
-                         forall args . Fullfilled "_backward_Convolution_v1(symbol)" args =>
-                           String ->
-                             ArgsHMap "_backward_Convolution_v1(symbol)" args -> IO SymbolHandle
-_backward_Convolution_v1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Convolution_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SequenceReverse(symbol)" =
-     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle),
-        '("sequence_length", AttrOpt SymbolHandle)]
-
-_SequenceReverse ::
-                 forall args . Fullfilled "_SequenceReverse(symbol)" args =>
-                   String ->
-                     ArgsHMap "_SequenceReverse(symbol)" args -> IO SymbolHandle
-_SequenceReverse name args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceReverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SequenceReverse(symbol)" =
-     '[]
-
-_backward_SequenceReverse ::
-                          forall args .
-                            Fullfilled "_backward_SequenceReverse(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_SequenceReverse(symbol)" args ->
-                                IO SymbolHandle
-_backward_SequenceReverse name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceReverse"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_BilinearSampler(symbol)" =
-     '[ '("cudnn_off", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt SymbolHandle), '("grid", AttrOpt SymbolHandle)]
-
-_BilinearSampler ::
-                 forall args . Fullfilled "_BilinearSampler(symbol)" args =>
-                   String ->
-                     ArgsHMap "_BilinearSampler(symbol)" args -> IO SymbolHandle
-_BilinearSampler name args
-  = let scalarArgs
-          = catMaybes
-              [("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("grid",) <$> (args !? #grid :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "BilinearSampler"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_BilinearSampler(symbol)" =
-     '[]
-
-_backward_BilinearSampler ::
-                          forall args .
-                            Fullfilled "_backward_BilinearSampler(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_BilinearSampler(symbol)" args ->
-                                IO SymbolHandle
-_backward_BilinearSampler name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BilinearSampler"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_LeakyReLU(symbol)" = '[]
-
-_backward_LeakyReLU ::
-                    forall args . Fullfilled "_backward_LeakyReLU(symbol)" args =>
-                      String ->
-                        ArgsHMap "_backward_LeakyReLU(symbol)" args -> IO SymbolHandle
-_backward_LeakyReLU name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_LeakyReLU"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Crop(symbol)" =
-     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),
-        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),
-        '("data", AttrOpt [SymbolHandle])]
-
-_Crop ::
-      forall args . Fullfilled "_Crop(symbol)" args =>
-        String -> ArgsHMap "_Crop(symbol)" args -> IO SymbolHandle
-_Crop name args
-  = let scalarArgs
-          = catMaybes
-              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
-               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),
-               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),
-               ("center_crop",) . showValue <$>
-                 (args !? #center_crop :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-        array = fromMaybe [] (args !? #data :: Maybe [SymbolHandle])
-      in
-      do op <- nnGetOpHandle "Crop"
-         sym <- if hasKey args #num_args then
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys scalarvals
-                  else
-                  mxSymbolCreateAtomicSymbol (fromOpHandle op)
-                    ("num_args" : scalarkeys)
-                    (showValue (length array) : scalarvals)
-         mxSymbolCompose sym name Nothing array
-         return sym
-
-type instance ParameterList "_backward_Crop(symbol)" = '[]
-
-_backward_Crop ::
-               forall args . Fullfilled "_backward_Crop(symbol)" args =>
-                 String -> ArgsHMap "_backward_Crop(symbol)" args -> IO SymbolHandle
-_backward_Crop name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Crop"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_ROIPooling(symbol)" =
-     '[ '("pooled_size", AttrReq [Int]),
-        '("spatial_scale", AttrReq Float), '("data", AttrOpt SymbolHandle),
-        '("rois", AttrOpt SymbolHandle)]
-
-_ROIPooling ::
-            forall args . Fullfilled "_ROIPooling(symbol)" args =>
-              String -> ArgsHMap "_ROIPooling(symbol)" args -> IO SymbolHandle
-_ROIPooling name args
-  = let scalarArgs
-          = catMaybes
-              [("pooled_size",) . showValue <$>
-                 (args !? #pooled_size :: Maybe [Int]),
-               ("spatial_scale",) . showValue <$>
-                 (args !? #spatial_scale :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("rois",) <$> (args !? #rois :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "ROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_ROIPooling(symbol)" = '[]
-
-_backward_ROIPooling ::
-                     forall args . Fullfilled "_backward_ROIPooling(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_ROIPooling(symbol)" args -> IO SymbolHandle
-_backward_ROIPooling name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_ROIPooling"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SequenceLast(symbol)" =
-     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle),
-        '("sequence_length", AttrOpt SymbolHandle)]
-
-_SequenceLast ::
-              forall args . Fullfilled "_SequenceLast(symbol)" args =>
-                String -> ArgsHMap "_SequenceLast(symbol)" args -> IO SymbolHandle
-_SequenceLast name args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceLast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SequenceLast(symbol)" = '[]
-
-_backward_SequenceLast ::
-                       forall args . Fullfilled "_backward_SequenceLast(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_SequenceLast(symbol)" args -> IO SymbolHandle
-_backward_SequenceLast name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceLast"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_CrossDeviceCopy(symbol)" = '[]
-
-_CrossDeviceCopy ::
-                 forall args . Fullfilled "_CrossDeviceCopy(symbol)" args =>
-                   String ->
-                     ArgsHMap "_CrossDeviceCopy(symbol)" args -> IO SymbolHandle
-_CrossDeviceCopy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_CrossDeviceCopy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward__CrossDeviceCopy(symbol)" =
-     '[]
-
-_backward__CrossDeviceCopy ::
-                           forall args .
-                             Fullfilled "_backward__CrossDeviceCopy(symbol)" args =>
-                             String ->
-                               ArgsHMap "_backward__CrossDeviceCopy(symbol)" args ->
-                                 IO SymbolHandle
-_backward__CrossDeviceCopy name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward__CrossDeviceCopy"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SpatialTransformer(symbol)" =
-     '[ '("target_shape", AttrOpt [Int]),
-        '("transform_type", AttrReq (EnumType '["affine"])),
-        '("sampler_type", AttrReq (EnumType '["bilinear"])),
-        '("cudnn_off", AttrOpt (Maybe Bool)),
-        '("data", AttrOpt SymbolHandle), '("loc", AttrOpt SymbolHandle)]
-
-_SpatialTransformer ::
-                    forall args . Fullfilled "_SpatialTransformer(symbol)" args =>
-                      String ->
-                        ArgsHMap "_SpatialTransformer(symbol)" args -> IO SymbolHandle
-_SpatialTransformer name args
-  = let scalarArgs
-          = catMaybes
-              [("target_shape",) . showValue <$>
-                 (args !? #target_shape :: Maybe [Int]),
-               ("transform_type",) . showValue <$>
-                 (args !? #transform_type :: Maybe (EnumType '["affine"])),
-               ("sampler_type",) . showValue <$>
-                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"])),
-               ("cudnn_off",) . showValue <$>
-                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("loc",) <$> (args !? #loc :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SpatialTransformer"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SpatialTransformer(symbol)"
-     = '[]
-
-_backward_SpatialTransformer ::
-                             forall args .
-                               Fullfilled "_backward_SpatialTransformer(symbol)" args =>
-                               String ->
-                                 ArgsHMap "_backward_SpatialTransformer(symbol)" args ->
-                                   IO SymbolHandle
-_backward_SpatialTransformer name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SpatialTransformer"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SwapAxis(symbol)" = '[]
-
-_backward_SwapAxis ::
-                   forall args . Fullfilled "_backward_SwapAxis(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_SwapAxis(symbol)" args -> IO SymbolHandle
-_backward_SwapAxis name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SwapAxis"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_L2Normalization(symbol)" =
-     '[ '("eps", AttrOpt Float),
-        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_L2Normalization ::
-                 forall args . Fullfilled "_L2Normalization(symbol)" args =>
-                   String ->
-                     ArgsHMap "_L2Normalization(symbol)" args -> IO SymbolHandle
-_L2Normalization name args
-  = let scalarArgs
-          = catMaybes
-              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
-               ("mode",) . showValue <$>
-                 (args !? #mode ::
-                    Maybe (EnumType '["channel", "instance", "spatial"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "L2Normalization"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_L2Normalization(symbol)" =
-     '[]
-
-_backward_L2Normalization ::
-                          forall args .
-                            Fullfilled "_backward_L2Normalization(symbol)" args =>
-                            String ->
-                              ArgsHMap "_backward_L2Normalization(symbol)" args ->
-                                IO SymbolHandle
-_backward_L2Normalization name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_L2Normalization"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Correlation(symbol)" =
-     '[ '("kernel_size", AttrOpt Int),
-        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),
-        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),
-        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt SymbolHandle),
-        '("data2", AttrOpt SymbolHandle)]
-
-_Correlation ::
-             forall args . Fullfilled "_Correlation(symbol)" args =>
-               String -> ArgsHMap "_Correlation(symbol)" args -> IO SymbolHandle
-_Correlation name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel_size",) . showValue <$>
-                 (args !? #kernel_size :: Maybe Int),
-               ("max_displacement",) . showValue <$>
-                 (args !? #max_displacement :: Maybe Int),
-               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),
-               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),
-               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),
-               ("is_multiply",) . showValue <$>
-                 (args !? #is_multiply :: Maybe Bool)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data1",) <$> (args !? #data1 :: Maybe SymbolHandle),
-               ("data2",) <$> (args !? #data2 :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Correlation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Correlation(symbol)" = '[]
-
-_backward_Correlation ::
-                      forall args . Fullfilled "_backward_Correlation(symbol)" args =>
-                        String ->
-                          ArgsHMap "_backward_Correlation(symbol)" args -> IO SymbolHandle
-_backward_Correlation name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Correlation"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance
-     ParameterList "_backward_IdentityAttachKLSparseReg(symbol)" = '[]
-
-_backward_IdentityAttachKLSparseReg ::
-                                    forall args .
-                                      Fullfilled "_backward_IdentityAttachKLSparseReg(symbol)"
-                                        args =>
-                                      String ->
-                                        ArgsHMap "_backward_IdentityAttachKLSparseReg(symbol)" args
-                                          -> IO SymbolHandle
-_backward_IdentityAttachKLSparseReg name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_IdentityAttachKLSparseReg"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_MakeLoss(symbol)" =
-     '[ '("grad_scale", AttrOpt Float),
-        '("valid_thresh", AttrOpt Float),
-        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
-        '("data", AttrOpt SymbolHandle)]
-
-_MakeLoss ::
-          forall args . Fullfilled "_MakeLoss(symbol)" args =>
-            String -> ArgsHMap "_MakeLoss(symbol)" args -> IO SymbolHandle
-_MakeLoss name args
-  = let scalarArgs
-          = catMaybes
-              [("grad_scale",) . showValue <$>
-                 (args !? #grad_scale :: Maybe Float),
-               ("valid_thresh",) . showValue <$>
-                 (args !? #valid_thresh :: Maybe Float),
-               ("normalization",) . showValue <$>
-                 (args !? #normalization ::
-                    Maybe (EnumType '["batch", "null", "valid"]))]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "MakeLoss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_MakeLoss(symbol)" = '[]
-
-_backward_MakeLoss ::
-                   forall args . Fullfilled "_backward_MakeLoss(symbol)" args =>
-                     String ->
-                       ArgsHMap "_backward_MakeLoss(symbol)" args -> IO SymbolHandle
-_backward_MakeLoss name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_MakeLoss"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SliceChannel(symbol)" = '[]
-
-_backward_SliceChannel ::
-                       forall args . Fullfilled "_backward_SliceChannel(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_SliceChannel(symbol)" args -> IO SymbolHandle
-_backward_SliceChannel name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SliceChannel"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_Pooling_v1(symbol)" =
-     '[ '("kernel", AttrOpt [Int]),
-        '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])),
-        '("global_pool", AttrOpt Bool),
-        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
-        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
-        '("data", AttrOpt SymbolHandle)]
-
-_Pooling_v1 ::
-            forall args . Fullfilled "_Pooling_v1(symbol)" args =>
-              String -> ArgsHMap "_Pooling_v1(symbol)" args -> IO SymbolHandle
-_Pooling_v1 name args
-  = let scalarArgs
-          = catMaybes
-              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
-               ("pool_type",) . showValue <$>
-                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
-               ("global_pool",) . showValue <$>
-                 (args !? #global_pool :: Maybe Bool),
-               ("pooling_convention",) . showValue <$>
-                 (args !? #pooling_convention ::
-                    Maybe (EnumType '["full", "valid"])),
-               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
-               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("data",) <$> (args !? #data :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "Pooling_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Pooling_v1(symbol)" = '[]
-
-_backward_Pooling_v1 ::
-                     forall args . Fullfilled "_backward_Pooling_v1(symbol)" args =>
-                       String ->
-                         ArgsHMap "_backward_Pooling_v1(symbol)" args -> IO SymbolHandle
-_backward_Pooling_v1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pooling_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_Pad(symbol)" = '[]
-
-_backward_Pad ::
-              forall args . Fullfilled "_backward_Pad(symbol)" args =>
-                String -> ArgsHMap "_backward_Pad(symbol)" args -> IO SymbolHandle
-_backward_Pad name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_Pad"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_BatchNorm_v1(symbol)" = '[]
-
-_backward_BatchNorm_v1 ::
-                       forall args . Fullfilled "_backward_BatchNorm_v1(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_BatchNorm_v1(symbol)" args -> IO SymbolHandle
-_backward_BatchNorm_v1 name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_BatchNorm_v1"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_SequenceMask(symbol)" =
-     '[ '("use_sequence_length", AttrOpt Bool),
-        '("value", AttrOpt Float), '("axis", AttrOpt Int),
-        '("data", AttrOpt SymbolHandle),
-        '("sequence_length", AttrOpt SymbolHandle)]
-
-_SequenceMask ::
-              forall args . Fullfilled "_SequenceMask(symbol)" args =>
-                String -> ArgsHMap "_SequenceMask(symbol)" args -> IO SymbolHandle
-_SequenceMask name args
-  = let scalarArgs
-          = catMaybes
-              [("use_sequence_length",) . showValue <$>
-                 (args !? #use_sequence_length :: Maybe Bool),
-               ("value",) . showValue <$> (args !? #value :: Maybe Float),
-               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes
-              [("data",) <$> (args !? #data :: Maybe SymbolHandle),
-               ("sequence_length",) <$>
-                 (args !? #sequence_length :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "SequenceMask"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_backward_SequenceMask(symbol)" = '[]
-
-_backward_SequenceMask ::
-                       forall args . Fullfilled "_backward_SequenceMask(symbol)" args =>
-                         String ->
-                           ArgsHMap "_backward_SequenceMask(symbol)" args -> IO SymbolHandle
-_backward_SequenceMask name args
-  = let scalarArgs = catMaybes []
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_backward_SequenceMask"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_set_value(symbol)" =
-     '[ '("src", AttrOpt Float)]
-
-_set_value ::
-           forall args . Fullfilled "_set_value(symbol)" args =>
-             String -> ArgsHMap "_set_value(symbol)" args -> IO SymbolHandle
-_set_value name args
-  = let scalarArgs
-          = catMaybes
-              [("src",) . showValue <$> (args !? #src :: Maybe Float)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs = catMaybes []
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_set_value"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
-
-type instance ParameterList "_imdecode(symbol)" =
-     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),
-        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),
-        '("c", AttrOpt Int), '("size", AttrOpt Int),
-        '("mean", AttrOpt SymbolHandle)]
-
-_imdecode ::
-          forall args . Fullfilled "_imdecode(symbol)" args =>
-            String -> ArgsHMap "_imdecode(symbol)" args -> IO SymbolHandle
-_imdecode name args
-  = let scalarArgs
-          = catMaybes
-              [("index",) . showValue <$> (args !? #index :: Maybe Int),
-               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),
-               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),
-               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),
-               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),
-               ("c",) . showValue <$> (args !? #c :: Maybe Int),
-               ("size",) . showValue <$> (args !? #size :: Maybe Int)]
-        (scalarkeys, scalarvals) = unzip scalarArgs
-        tensorArgs
-          = catMaybes [("mean",) <$> (args !? #mean :: Maybe SymbolHandle)]
-        (tensorkeys, tensorvals) = unzip tensorArgs
-      in
-      do op <- nnGetOpHandle "_imdecode"
-         sym <- mxSymbolCreateAtomicSymbol (fromOpHandle op) scalarkeys
-                  scalarvals
-         mxSymbolCompose sym name (Just tensorkeys) tensorvals
-         return sym
diff --git a/ops/1.6/MXNet/Base/DataIter.hs b/ops/1.6/MXNet/Base/DataIter.hs
new file mode 100644
--- /dev/null
+++ b/ops/1.6/MXNet/Base/DataIter.hs
@@ -0,0 +1,1055 @@
+module MXNet.Base.DataIter where
+import RIO
+import RIO.List
+import RIO.List.Partial ((!!))
+import MXNet.Base.Raw
+import MXNet.Base.Spec.Operator
+import MXNet.Base.Spec.HMap
+import Data.Maybe (catMaybes, fromMaybe)
+
+type instance ParameterList "_CSVIter" dummy =
+     '[ '("data_csv", AttrReq Text), '("data_shape", AttrReq [Int]),
+        '("label_csv", AttrOpt Text), '("label_shape", AttrOpt [Int]),
+        '("batch_size", AttrReq Int), '("round_batch", AttrOpt Bool),
+        '("prefetch_buffer", AttrOpt Int),
+        '("ctx", AttrOpt (EnumType '["cpu", "gpu"])),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["float16", "float32", "float64", "int32", "int64", "int8",
+                    "uint8"])))]
+
+_CSVIter ::
+         forall a . Fullfilled "_CSVIter" () a =>
+           ArgsHMap "_CSVIter" () a -> IO DataIterHandle
+_CSVIter args
+  = let allargs
+          = catMaybes
+              [("data_csv",) . showValue <$> (args !? #data_csv :: Maybe Text),
+               ("data_shape",) . showValue <$>
+                 (args !? #data_shape :: Maybe [Int]),
+               ("label_csv",) . showValue <$> (args !? #label_csv :: Maybe Text),
+               ("label_shape",) . showValue <$>
+                 (args !? #label_shape :: Maybe [Int]),
+               ("batch_size",) . showValue <$> (args !? #batch_size :: Maybe Int),
+               ("round_batch",) . showValue <$>
+                 (args !? #round_batch :: Maybe Bool),
+               ("prefetch_buffer",) . showValue <$>
+                 (args !? #prefetch_buffer :: Maybe Int),
+               ("ctx",) . showValue <$>
+                 (args !? #ctx :: Maybe (EnumType '["cpu", "gpu"])),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["float16", "float32", "float64", "int32", "int64", "int8",
+                              "uint8"])))]
+        (keys, vals) = unzip allargs
+      in
+      do dis <- mxListDataIters
+         di <- return (dis !! 0)
+         mxDataIterCreateIter di keys vals
+
+type instance ParameterList "_ImageDetRecordIter" dummy =
+     '[ '("path_imglist", AttrOpt Text), '("path_imgrec", AttrOpt Text),
+        '("aug_seq", AttrOpt Text), '("label_width", AttrOpt Int),
+        '("data_shape", AttrReq [Int]),
+        '("preprocess_threads", AttrOpt Int), '("verbose", AttrOpt Bool),
+        '("num_parts", AttrOpt Int), '("part_index", AttrOpt Int),
+        '("shuffle_chunk_size", AttrOpt Int),
+        '("shuffle_chunk_seed", AttrOpt Int),
+        '("label_pad_width", AttrOpt Int),
+        '("label_pad_value", AttrOpt Float), '("shuffle", AttrOpt Bool),
+        '("seed", AttrOpt Int), '("verbose", AttrOpt Bool),
+        '("batch_size", AttrReq Int), '("round_batch", AttrOpt Bool),
+        '("prefetch_buffer", AttrOpt Int),
+        '("ctx", AttrOpt (EnumType '["cpu", "gpu"])),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["float16", "float32", "float64", "int32", "int64", "int8",
+                    "uint8"]))),
+        '("resize", AttrOpt Int), '("rand_crop_prob", AttrOpt Float),
+        '("min_crop_scales", AttrOpt [Float]),
+        '("max_crop_scales", AttrOpt [Float]),
+        '("min_crop_aspect_ratios", AttrOpt [Float]),
+        '("max_crop_aspect_ratios", AttrOpt [Float]),
+        '("min_crop_overlaps", AttrOpt [Float]),
+        '("max_crop_overlaps", AttrOpt [Float]),
+        '("min_crop_sample_coverages", AttrOpt [Float]),
+        '("max_crop_sample_coverages", AttrOpt [Float]),
+        '("min_crop_object_coverages", AttrOpt [Float]),
+        '("max_crop_object_coverages", AttrOpt [Float]),
+        '("num_crop_sampler", AttrOpt Int),
+        '("crop_emit_mode", AttrOpt (EnumType '["center", "overlap"])),
+        '("emit_overlap_thresh", AttrOpt Float),
+        '("max_crop_trials", AttrOpt [Int]),
+        '("rand_pad_prob", AttrOpt Float),
+        '("max_pad_scale", AttrOpt Float),
+        '("max_random_hue", AttrOpt Int),
+        '("random_hue_prob", AttrOpt Float),
+        '("max_random_saturation", AttrOpt Int),
+        '("random_saturation_prob", AttrOpt Float),
+        '("max_random_illumination", AttrOpt Int),
+        '("random_illumination_prob", AttrOpt Float),
+        '("max_random_contrast", AttrOpt Float),
+        '("random_contrast_prob", AttrOpt Float),
+        '("rand_mirror_prob", AttrOpt Float), '("fill_value", AttrOpt Int),
+        '("inter_method", AttrOpt Int), '("data_shape", AttrReq [Int]),
+        '("resize_mode", AttrOpt (EnumType '["fit", "force", "shrink"])),
+        '("seed", AttrOpt Int), '("mean_img", AttrOpt Text),
+        '("mean_r", AttrOpt Float), '("mean_g", AttrOpt Float),
+        '("mean_b", AttrOpt Float), '("mean_a", AttrOpt Float),
+        '("std_r", AttrOpt Float), '("std_g", AttrOpt Float),
+        '("std_b", AttrOpt Float), '("std_a", AttrOpt Float),
+        '("scale", AttrOpt Float), '("verbose", AttrOpt Bool)]
+
+_ImageDetRecordIter ::
+                    forall a . Fullfilled "_ImageDetRecordIter" () a =>
+                      ArgsHMap "_ImageDetRecordIter" () a -> IO DataIterHandle
+_ImageDetRecordIter args
+  = let allargs
+          = catMaybes
+              [("path_imglist",) . showValue <$>
+                 (args !? #path_imglist :: Maybe Text),
+               ("path_imgrec",) . showValue <$>
+                 (args !? #path_imgrec :: Maybe Text),
+               ("aug_seq",) . showValue <$> (args !? #aug_seq :: Maybe Text),
+               ("label_width",) . showValue <$>
+                 (args !? #label_width :: Maybe Int),
+               ("data_shape",) . showValue <$>
+                 (args !? #data_shape :: Maybe [Int]),
+               ("preprocess_threads",) . showValue <$>
+                 (args !? #preprocess_threads :: Maybe Int),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool),
+               ("num_parts",) . showValue <$> (args !? #num_parts :: Maybe Int),
+               ("part_index",) . showValue <$> (args !? #part_index :: Maybe Int),
+               ("shuffle_chunk_size",) . showValue <$>
+                 (args !? #shuffle_chunk_size :: Maybe Int),
+               ("shuffle_chunk_seed",) . showValue <$>
+                 (args !? #shuffle_chunk_seed :: Maybe Int),
+               ("label_pad_width",) . showValue <$>
+                 (args !? #label_pad_width :: Maybe Int),
+               ("label_pad_value",) . showValue <$>
+                 (args !? #label_pad_value :: Maybe Float),
+               ("shuffle",) . showValue <$> (args !? #shuffle :: Maybe Bool),
+               ("seed",) . showValue <$> (args !? #seed :: Maybe Int),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool),
+               ("batch_size",) . showValue <$> (args !? #batch_size :: Maybe Int),
+               ("round_batch",) . showValue <$>
+                 (args !? #round_batch :: Maybe Bool),
+               ("prefetch_buffer",) . showValue <$>
+                 (args !? #prefetch_buffer :: Maybe Int),
+               ("ctx",) . showValue <$>
+                 (args !? #ctx :: Maybe (EnumType '["cpu", "gpu"])),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["float16", "float32", "float64", "int32", "int64", "int8",
+                              "uint8"]))),
+               ("resize",) . showValue <$> (args !? #resize :: Maybe Int),
+               ("rand_crop_prob",) . showValue <$>
+                 (args !? #rand_crop_prob :: Maybe Float),
+               ("min_crop_scales",) . showValue <$>
+                 (args !? #min_crop_scales :: Maybe [Float]),
+               ("max_crop_scales",) . showValue <$>
+                 (args !? #max_crop_scales :: Maybe [Float]),
+               ("min_crop_aspect_ratios",) . showValue <$>
+                 (args !? #min_crop_aspect_ratios :: Maybe [Float]),
+               ("max_crop_aspect_ratios",) . showValue <$>
+                 (args !? #max_crop_aspect_ratios :: Maybe [Float]),
+               ("min_crop_overlaps",) . showValue <$>
+                 (args !? #min_crop_overlaps :: Maybe [Float]),
+               ("max_crop_overlaps",) . showValue <$>
+                 (args !? #max_crop_overlaps :: Maybe [Float]),
+               ("min_crop_sample_coverages",) . showValue <$>
+                 (args !? #min_crop_sample_coverages :: Maybe [Float]),
+               ("max_crop_sample_coverages",) . showValue <$>
+                 (args !? #max_crop_sample_coverages :: Maybe [Float]),
+               ("min_crop_object_coverages",) . showValue <$>
+                 (args !? #min_crop_object_coverages :: Maybe [Float]),
+               ("max_crop_object_coverages",) . showValue <$>
+                 (args !? #max_crop_object_coverages :: Maybe [Float]),
+               ("num_crop_sampler",) . showValue <$>
+                 (args !? #num_crop_sampler :: Maybe Int),
+               ("crop_emit_mode",) . showValue <$>
+                 (args !? #crop_emit_mode ::
+                    Maybe (EnumType '["center", "overlap"])),
+               ("emit_overlap_thresh",) . showValue <$>
+                 (args !? #emit_overlap_thresh :: Maybe Float),
+               ("max_crop_trials",) . showValue <$>
+                 (args !? #max_crop_trials :: Maybe [Int]),
+               ("rand_pad_prob",) . showValue <$>
+                 (args !? #rand_pad_prob :: Maybe Float),
+               ("max_pad_scale",) . showValue <$>
+                 (args !? #max_pad_scale :: Maybe Float),
+               ("max_random_hue",) . showValue <$>
+                 (args !? #max_random_hue :: Maybe Int),
+               ("random_hue_prob",) . showValue <$>
+                 (args !? #random_hue_prob :: Maybe Float),
+               ("max_random_saturation",) . showValue <$>
+                 (args !? #max_random_saturation :: Maybe Int),
+               ("random_saturation_prob",) . showValue <$>
+                 (args !? #random_saturation_prob :: Maybe Float),
+               ("max_random_illumination",) . showValue <$>
+                 (args !? #max_random_illumination :: Maybe Int),
+               ("random_illumination_prob",) . showValue <$>
+                 (args !? #random_illumination_prob :: Maybe Float),
+               ("max_random_contrast",) . showValue <$>
+                 (args !? #max_random_contrast :: Maybe Float),
+               ("random_contrast_prob",) . showValue <$>
+                 (args !? #random_contrast_prob :: Maybe Float),
+               ("rand_mirror_prob",) . showValue <$>
+                 (args !? #rand_mirror_prob :: Maybe Float),
+               ("fill_value",) . showValue <$> (args !? #fill_value :: Maybe Int),
+               ("inter_method",) . showValue <$>
+                 (args !? #inter_method :: Maybe Int),
+               ("data_shape",) . showValue <$>
+                 (args !? #data_shape :: Maybe [Int]),
+               ("resize_mode",) . showValue <$>
+                 (args !? #resize_mode ::
+                    Maybe (EnumType '["fit", "force", "shrink"])),
+               ("seed",) . showValue <$> (args !? #seed :: Maybe Int),
+               ("mean_img",) . showValue <$> (args !? #mean_img :: Maybe Text),
+               ("mean_r",) . showValue <$> (args !? #mean_r :: Maybe Float),
+               ("mean_g",) . showValue <$> (args !? #mean_g :: Maybe Float),
+               ("mean_b",) . showValue <$> (args !? #mean_b :: Maybe Float),
+               ("mean_a",) . showValue <$> (args !? #mean_a :: Maybe Float),
+               ("std_r",) . showValue <$> (args !? #std_r :: Maybe Float),
+               ("std_g",) . showValue <$> (args !? #std_g :: Maybe Float),
+               ("std_b",) . showValue <$> (args !? #std_b :: Maybe Float),
+               ("std_a",) . showValue <$> (args !? #std_a :: Maybe Float),
+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool)]
+        (keys, vals) = unzip allargs
+      in
+      do dis <- mxListDataIters
+         di <- return (dis !! 1)
+         mxDataIterCreateIter di keys vals
+
+type instance ParameterList "_ImageRecordIter_v1" dummy =
+     '[ '("path_imglist", AttrOpt Text), '("path_imgrec", AttrOpt Text),
+        '("path_imgidx", AttrOpt Text), '("aug_seq", AttrOpt Text),
+        '("label_width", AttrOpt Int), '("data_shape", AttrReq [Int]),
+        '("preprocess_threads", AttrOpt Int), '("verbose", AttrOpt Bool),
+        '("num_parts", AttrOpt Int), '("part_index", AttrOpt Int),
+        '("device_id", AttrOpt Int), '("shuffle_chunk_size", AttrOpt Int),
+        '("shuffle_chunk_seed", AttrOpt Int),
+        '("seed_aug", AttrOpt (Maybe Int)), '("shuffle", AttrOpt Bool),
+        '("seed", AttrOpt Int), '("verbose", AttrOpt Bool),
+        '("batch_size", AttrReq Int), '("round_batch", AttrOpt Bool),
+        '("prefetch_buffer", AttrOpt Int),
+        '("ctx", AttrOpt (EnumType '["cpu", "gpu"])),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["float16", "float32", "float64", "int32", "int64", "int8",
+                    "uint8"]))),
+        '("resize", AttrOpt Int), '("rand_crop", AttrOpt Bool),
+        '("random_resized_crop", AttrOpt Bool),
+        '("max_rotate_angle", AttrOpt Int),
+        '("max_aspect_ratio", AttrOpt Float),
+        '("min_aspect_ratio", AttrOpt (Maybe Float)),
+        '("max_shear_ratio", AttrOpt Float),
+        '("max_crop_size", AttrOpt Int), '("min_crop_size", AttrOpt Int),
+        '("max_random_scale", AttrOpt Float),
+        '("min_random_scale", AttrOpt Float),
+        '("max_random_area", AttrOpt Float),
+        '("min_random_area", AttrOpt Float),
+        '("max_img_size", AttrOpt Float), '("min_img_size", AttrOpt Float),
+        '("brightness", AttrOpt Float), '("contrast", AttrOpt Float),
+        '("saturation", AttrOpt Float), '("pca_noise", AttrOpt Float),
+        '("random_h", AttrOpt Int), '("random_s", AttrOpt Int),
+        '("random_l", AttrOpt Int), '("rotate", AttrOpt Int),
+        '("fill_value", AttrOpt Int), '("data_shape", AttrReq [Int]),
+        '("inter_method", AttrOpt Int), '("pad", AttrOpt Int),
+        '("seed", AttrOpt Int), '("mirror", AttrOpt Bool),
+        '("rand_mirror", AttrOpt Bool), '("mean_img", AttrOpt Text),
+        '("mean_r", AttrOpt Float), '("mean_g", AttrOpt Float),
+        '("mean_b", AttrOpt Float), '("mean_a", AttrOpt Float),
+        '("std_r", AttrOpt Float), '("std_g", AttrOpt Float),
+        '("std_b", AttrOpt Float), '("std_a", AttrOpt Float),
+        '("scale", AttrOpt Float), '("max_random_contrast", AttrOpt Float),
+        '("max_random_illumination", AttrOpt Float),
+        '("verbose", AttrOpt Bool)]
+
+_ImageRecordIter_v1 ::
+                    forall a . Fullfilled "_ImageRecordIter_v1" () a =>
+                      ArgsHMap "_ImageRecordIter_v1" () a -> IO DataIterHandle
+_ImageRecordIter_v1 args
+  = let allargs
+          = catMaybes
+              [("path_imglist",) . showValue <$>
+                 (args !? #path_imglist :: Maybe Text),
+               ("path_imgrec",) . showValue <$>
+                 (args !? #path_imgrec :: Maybe Text),
+               ("path_imgidx",) . showValue <$>
+                 (args !? #path_imgidx :: Maybe Text),
+               ("aug_seq",) . showValue <$> (args !? #aug_seq :: Maybe Text),
+               ("label_width",) . showValue <$>
+                 (args !? #label_width :: Maybe Int),
+               ("data_shape",) . showValue <$>
+                 (args !? #data_shape :: Maybe [Int]),
+               ("preprocess_threads",) . showValue <$>
+                 (args !? #preprocess_threads :: Maybe Int),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool),
+               ("num_parts",) . showValue <$> (args !? #num_parts :: Maybe Int),
+               ("part_index",) . showValue <$> (args !? #part_index :: Maybe Int),
+               ("device_id",) . showValue <$> (args !? #device_id :: Maybe Int),
+               ("shuffle_chunk_size",) . showValue <$>
+                 (args !? #shuffle_chunk_size :: Maybe Int),
+               ("shuffle_chunk_seed",) . showValue <$>
+                 (args !? #shuffle_chunk_seed :: Maybe Int),
+               ("seed_aug",) . showValue <$>
+                 (args !? #seed_aug :: Maybe (Maybe Int)),
+               ("shuffle",) . showValue <$> (args !? #shuffle :: Maybe Bool),
+               ("seed",) . showValue <$> (args !? #seed :: Maybe Int),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool),
+               ("batch_size",) . showValue <$> (args !? #batch_size :: Maybe Int),
+               ("round_batch",) . showValue <$>
+                 (args !? #round_batch :: Maybe Bool),
+               ("prefetch_buffer",) . showValue <$>
+                 (args !? #prefetch_buffer :: Maybe Int),
+               ("ctx",) . showValue <$>
+                 (args !? #ctx :: Maybe (EnumType '["cpu", "gpu"])),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["float16", "float32", "float64", "int32", "int64", "int8",
+                              "uint8"]))),
+               ("resize",) . showValue <$> (args !? #resize :: Maybe Int),
+               ("rand_crop",) . showValue <$> (args !? #rand_crop :: Maybe Bool),
+               ("random_resized_crop",) . showValue <$>
+                 (args !? #random_resized_crop :: Maybe Bool),
+               ("max_rotate_angle",) . showValue <$>
+                 (args !? #max_rotate_angle :: Maybe Int),
+               ("max_aspect_ratio",) . showValue <$>
+                 (args !? #max_aspect_ratio :: Maybe Float),
+               ("min_aspect_ratio",) . showValue <$>
+                 (args !? #min_aspect_ratio :: Maybe (Maybe Float)),
+               ("max_shear_ratio",) . showValue <$>
+                 (args !? #max_shear_ratio :: Maybe Float),
+               ("max_crop_size",) . showValue <$>
+                 (args !? #max_crop_size :: Maybe Int),
+               ("min_crop_size",) . showValue <$>
+                 (args !? #min_crop_size :: Maybe Int),
+               ("max_random_scale",) . showValue <$>
+                 (args !? #max_random_scale :: Maybe Float),
+               ("min_random_scale",) . showValue <$>
+                 (args !? #min_random_scale :: Maybe Float),
+               ("max_random_area",) . showValue <$>
+                 (args !? #max_random_area :: Maybe Float),
+               ("min_random_area",) . showValue <$>
+                 (args !? #min_random_area :: Maybe Float),
+               ("max_img_size",) . showValue <$>
+                 (args !? #max_img_size :: Maybe Float),
+               ("min_img_size",) . showValue <$>
+                 (args !? #min_img_size :: Maybe Float),
+               ("brightness",) . showValue <$>
+                 (args !? #brightness :: Maybe Float),
+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
+               ("saturation",) . showValue <$>
+                 (args !? #saturation :: Maybe Float),
+               ("pca_noise",) . showValue <$> (args !? #pca_noise :: Maybe Float),
+               ("random_h",) . showValue <$> (args !? #random_h :: Maybe Int),
+               ("random_s",) . showValue <$> (args !? #random_s :: Maybe Int),
+               ("random_l",) . showValue <$> (args !? #random_l :: Maybe Int),
+               ("rotate",) . showValue <$> (args !? #rotate :: Maybe Int),
+               ("fill_value",) . showValue <$> (args !? #fill_value :: Maybe Int),
+               ("data_shape",) . showValue <$>
+                 (args !? #data_shape :: Maybe [Int]),
+               ("inter_method",) . showValue <$>
+                 (args !? #inter_method :: Maybe Int),
+               ("pad",) . showValue <$> (args !? #pad :: Maybe Int),
+               ("seed",) . showValue <$> (args !? #seed :: Maybe Int),
+               ("mirror",) . showValue <$> (args !? #mirror :: Maybe Bool),
+               ("rand_mirror",) . showValue <$>
+                 (args !? #rand_mirror :: Maybe Bool),
+               ("mean_img",) . showValue <$> (args !? #mean_img :: Maybe Text),
+               ("mean_r",) . showValue <$> (args !? #mean_r :: Maybe Float),
+               ("mean_g",) . showValue <$> (args !? #mean_g :: Maybe Float),
+               ("mean_b",) . showValue <$> (args !? #mean_b :: Maybe Float),
+               ("mean_a",) . showValue <$> (args !? #mean_a :: Maybe Float),
+               ("std_r",) . showValue <$> (args !? #std_r :: Maybe Float),
+               ("std_g",) . showValue <$> (args !? #std_g :: Maybe Float),
+               ("std_b",) . showValue <$> (args !? #std_b :: Maybe Float),
+               ("std_a",) . showValue <$> (args !? #std_a :: Maybe Float),
+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
+               ("max_random_contrast",) . showValue <$>
+                 (args !? #max_random_contrast :: Maybe Float),
+               ("max_random_illumination",) . showValue <$>
+                 (args !? #max_random_illumination :: Maybe Float),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool)]
+        (keys, vals) = unzip allargs
+      in
+      do dis <- mxListDataIters
+         di <- return (dis !! 2)
+         mxDataIterCreateIter di keys vals
+
+type instance ParameterList "_ImageRecordUInt8Iter_v1" dummy =
+     '[ '("path_imglist", AttrOpt Text), '("path_imgrec", AttrOpt Text),
+        '("path_imgidx", AttrOpt Text), '("aug_seq", AttrOpt Text),
+        '("label_width", AttrOpt Int), '("data_shape", AttrReq [Int]),
+        '("preprocess_threads", AttrOpt Int), '("verbose", AttrOpt Bool),
+        '("num_parts", AttrOpt Int), '("part_index", AttrOpt Int),
+        '("device_id", AttrOpt Int), '("shuffle_chunk_size", AttrOpt Int),
+        '("shuffle_chunk_seed", AttrOpt Int),
+        '("seed_aug", AttrOpt (Maybe Int)), '("shuffle", AttrOpt Bool),
+        '("seed", AttrOpt Int), '("verbose", AttrOpt Bool),
+        '("batch_size", AttrReq Int), '("round_batch", AttrOpt Bool),
+        '("prefetch_buffer", AttrOpt Int),
+        '("ctx", AttrOpt (EnumType '["cpu", "gpu"])),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["float16", "float32", "float64", "int32", "int64", "int8",
+                    "uint8"]))),
+        '("resize", AttrOpt Int), '("rand_crop", AttrOpt Bool),
+        '("random_resized_crop", AttrOpt Bool),
+        '("max_rotate_angle", AttrOpt Int),
+        '("max_aspect_ratio", AttrOpt Float),
+        '("min_aspect_ratio", AttrOpt (Maybe Float)),
+        '("max_shear_ratio", AttrOpt Float),
+        '("max_crop_size", AttrOpt Int), '("min_crop_size", AttrOpt Int),
+        '("max_random_scale", AttrOpt Float),
+        '("min_random_scale", AttrOpt Float),
+        '("max_random_area", AttrOpt Float),
+        '("min_random_area", AttrOpt Float),
+        '("max_img_size", AttrOpt Float), '("min_img_size", AttrOpt Float),
+        '("brightness", AttrOpt Float), '("contrast", AttrOpt Float),
+        '("saturation", AttrOpt Float), '("pca_noise", AttrOpt Float),
+        '("random_h", AttrOpt Int), '("random_s", AttrOpt Int),
+        '("random_l", AttrOpt Int), '("rotate", AttrOpt Int),
+        '("fill_value", AttrOpt Int), '("data_shape", AttrReq [Int]),
+        '("inter_method", AttrOpt Int), '("pad", AttrOpt Int)]
+
+_ImageRecordUInt8Iter_v1 ::
+                         forall a . Fullfilled "_ImageRecordUInt8Iter_v1" () a =>
+                           ArgsHMap "_ImageRecordUInt8Iter_v1" () a -> IO DataIterHandle
+_ImageRecordUInt8Iter_v1 args
+  = let allargs
+          = catMaybes
+              [("path_imglist",) . showValue <$>
+                 (args !? #path_imglist :: Maybe Text),
+               ("path_imgrec",) . showValue <$>
+                 (args !? #path_imgrec :: Maybe Text),
+               ("path_imgidx",) . showValue <$>
+                 (args !? #path_imgidx :: Maybe Text),
+               ("aug_seq",) . showValue <$> (args !? #aug_seq :: Maybe Text),
+               ("label_width",) . showValue <$>
+                 (args !? #label_width :: Maybe Int),
+               ("data_shape",) . showValue <$>
+                 (args !? #data_shape :: Maybe [Int]),
+               ("preprocess_threads",) . showValue <$>
+                 (args !? #preprocess_threads :: Maybe Int),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool),
+               ("num_parts",) . showValue <$> (args !? #num_parts :: Maybe Int),
+               ("part_index",) . showValue <$> (args !? #part_index :: Maybe Int),
+               ("device_id",) . showValue <$> (args !? #device_id :: Maybe Int),
+               ("shuffle_chunk_size",) . showValue <$>
+                 (args !? #shuffle_chunk_size :: Maybe Int),
+               ("shuffle_chunk_seed",) . showValue <$>
+                 (args !? #shuffle_chunk_seed :: Maybe Int),
+               ("seed_aug",) . showValue <$>
+                 (args !? #seed_aug :: Maybe (Maybe Int)),
+               ("shuffle",) . showValue <$> (args !? #shuffle :: Maybe Bool),
+               ("seed",) . showValue <$> (args !? #seed :: Maybe Int),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool),
+               ("batch_size",) . showValue <$> (args !? #batch_size :: Maybe Int),
+               ("round_batch",) . showValue <$>
+                 (args !? #round_batch :: Maybe Bool),
+               ("prefetch_buffer",) . showValue <$>
+                 (args !? #prefetch_buffer :: Maybe Int),
+               ("ctx",) . showValue <$>
+                 (args !? #ctx :: Maybe (EnumType '["cpu", "gpu"])),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["float16", "float32", "float64", "int32", "int64", "int8",
+                              "uint8"]))),
+               ("resize",) . showValue <$> (args !? #resize :: Maybe Int),
+               ("rand_crop",) . showValue <$> (args !? #rand_crop :: Maybe Bool),
+               ("random_resized_crop",) . showValue <$>
+                 (args !? #random_resized_crop :: Maybe Bool),
+               ("max_rotate_angle",) . showValue <$>
+                 (args !? #max_rotate_angle :: Maybe Int),
+               ("max_aspect_ratio",) . showValue <$>
+                 (args !? #max_aspect_ratio :: Maybe Float),
+               ("min_aspect_ratio",) . showValue <$>
+                 (args !? #min_aspect_ratio :: Maybe (Maybe Float)),
+               ("max_shear_ratio",) . showValue <$>
+                 (args !? #max_shear_ratio :: Maybe Float),
+               ("max_crop_size",) . showValue <$>
+                 (args !? #max_crop_size :: Maybe Int),
+               ("min_crop_size",) . showValue <$>
+                 (args !? #min_crop_size :: Maybe Int),
+               ("max_random_scale",) . showValue <$>
+                 (args !? #max_random_scale :: Maybe Float),
+               ("min_random_scale",) . showValue <$>
+                 (args !? #min_random_scale :: Maybe Float),
+               ("max_random_area",) . showValue <$>
+                 (args !? #max_random_area :: Maybe Float),
+               ("min_random_area",) . showValue <$>
+                 (args !? #min_random_area :: Maybe Float),
+               ("max_img_size",) . showValue <$>
+                 (args !? #max_img_size :: Maybe Float),
+               ("min_img_size",) . showValue <$>
+                 (args !? #min_img_size :: Maybe Float),
+               ("brightness",) . showValue <$>
+                 (args !? #brightness :: Maybe Float),
+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
+               ("saturation",) . showValue <$>
+                 (args !? #saturation :: Maybe Float),
+               ("pca_noise",) . showValue <$> (args !? #pca_noise :: Maybe Float),
+               ("random_h",) . showValue <$> (args !? #random_h :: Maybe Int),
+               ("random_s",) . showValue <$> (args !? #random_s :: Maybe Int),
+               ("random_l",) . showValue <$> (args !? #random_l :: Maybe Int),
+               ("rotate",) . showValue <$> (args !? #rotate :: Maybe Int),
+               ("fill_value",) . showValue <$> (args !? #fill_value :: Maybe Int),
+               ("data_shape",) . showValue <$>
+                 (args !? #data_shape :: Maybe [Int]),
+               ("inter_method",) . showValue <$>
+                 (args !? #inter_method :: Maybe Int),
+               ("pad",) . showValue <$> (args !? #pad :: Maybe Int)]
+        (keys, vals) = unzip allargs
+      in
+      do dis <- mxListDataIters
+         di <- return (dis !! 3)
+         mxDataIterCreateIter di keys vals
+
+type instance ParameterList "_ImageRecordIter" dummy =
+     '[ '("path_imglist", AttrOpt Text), '("path_imgrec", AttrOpt Text),
+        '("path_imgidx", AttrOpt Text), '("aug_seq", AttrOpt Text),
+        '("label_width", AttrOpt Int), '("data_shape", AttrReq [Int]),
+        '("preprocess_threads", AttrOpt Int), '("verbose", AttrOpt Bool),
+        '("num_parts", AttrOpt Int), '("part_index", AttrOpt Int),
+        '("device_id", AttrOpt Int), '("shuffle_chunk_size", AttrOpt Int),
+        '("shuffle_chunk_seed", AttrOpt Int),
+        '("seed_aug", AttrOpt (Maybe Int)), '("shuffle", AttrOpt Bool),
+        '("seed", AttrOpt Int), '("verbose", AttrOpt Bool),
+        '("batch_size", AttrReq Int), '("round_batch", AttrOpt Bool),
+        '("prefetch_buffer", AttrOpt Int),
+        '("ctx", AttrOpt (EnumType '["cpu", "gpu"])),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["float16", "float32", "float64", "int32", "int64", "int8",
+                    "uint8"]))),
+        '("resize", AttrOpt Int), '("rand_crop", AttrOpt Bool),
+        '("random_resized_crop", AttrOpt Bool),
+        '("max_rotate_angle", AttrOpt Int),
+        '("max_aspect_ratio", AttrOpt Float),
+        '("min_aspect_ratio", AttrOpt (Maybe Float)),
+        '("max_shear_ratio", AttrOpt Float),
+        '("max_crop_size", AttrOpt Int), '("min_crop_size", AttrOpt Int),
+        '("max_random_scale", AttrOpt Float),
+        '("min_random_scale", AttrOpt Float),
+        '("max_random_area", AttrOpt Float),
+        '("min_random_area", AttrOpt Float),
+        '("max_img_size", AttrOpt Float), '("min_img_size", AttrOpt Float),
+        '("brightness", AttrOpt Float), '("contrast", AttrOpt Float),
+        '("saturation", AttrOpt Float), '("pca_noise", AttrOpt Float),
+        '("random_h", AttrOpt Int), '("random_s", AttrOpt Int),
+        '("random_l", AttrOpt Int), '("rotate", AttrOpt Int),
+        '("fill_value", AttrOpt Int), '("data_shape", AttrReq [Int]),
+        '("inter_method", AttrOpt Int), '("pad", AttrOpt Int),
+        '("seed", AttrOpt Int), '("mirror", AttrOpt Bool),
+        '("rand_mirror", AttrOpt Bool), '("mean_img", AttrOpt Text),
+        '("mean_r", AttrOpt Float), '("mean_g", AttrOpt Float),
+        '("mean_b", AttrOpt Float), '("mean_a", AttrOpt Float),
+        '("std_r", AttrOpt Float), '("std_g", AttrOpt Float),
+        '("std_b", AttrOpt Float), '("std_a", AttrOpt Float),
+        '("scale", AttrOpt Float), '("max_random_contrast", AttrOpt Float),
+        '("max_random_illumination", AttrOpt Float),
+        '("verbose", AttrOpt Bool)]
+
+_ImageRecordIter ::
+                 forall a . Fullfilled "_ImageRecordIter" () a =>
+                   ArgsHMap "_ImageRecordIter" () a -> IO DataIterHandle
+_ImageRecordIter args
+  = let allargs
+          = catMaybes
+              [("path_imglist",) . showValue <$>
+                 (args !? #path_imglist :: Maybe Text),
+               ("path_imgrec",) . showValue <$>
+                 (args !? #path_imgrec :: Maybe Text),
+               ("path_imgidx",) . showValue <$>
+                 (args !? #path_imgidx :: Maybe Text),
+               ("aug_seq",) . showValue <$> (args !? #aug_seq :: Maybe Text),
+               ("label_width",) . showValue <$>
+                 (args !? #label_width :: Maybe Int),
+               ("data_shape",) . showValue <$>
+                 (args !? #data_shape :: Maybe [Int]),
+               ("preprocess_threads",) . showValue <$>
+                 (args !? #preprocess_threads :: Maybe Int),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool),
+               ("num_parts",) . showValue <$> (args !? #num_parts :: Maybe Int),
+               ("part_index",) . showValue <$> (args !? #part_index :: Maybe Int),
+               ("device_id",) . showValue <$> (args !? #device_id :: Maybe Int),
+               ("shuffle_chunk_size",) . showValue <$>
+                 (args !? #shuffle_chunk_size :: Maybe Int),
+               ("shuffle_chunk_seed",) . showValue <$>
+                 (args !? #shuffle_chunk_seed :: Maybe Int),
+               ("seed_aug",) . showValue <$>
+                 (args !? #seed_aug :: Maybe (Maybe Int)),
+               ("shuffle",) . showValue <$> (args !? #shuffle :: Maybe Bool),
+               ("seed",) . showValue <$> (args !? #seed :: Maybe Int),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool),
+               ("batch_size",) . showValue <$> (args !? #batch_size :: Maybe Int),
+               ("round_batch",) . showValue <$>
+                 (args !? #round_batch :: Maybe Bool),
+               ("prefetch_buffer",) . showValue <$>
+                 (args !? #prefetch_buffer :: Maybe Int),
+               ("ctx",) . showValue <$>
+                 (args !? #ctx :: Maybe (EnumType '["cpu", "gpu"])),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["float16", "float32", "float64", "int32", "int64", "int8",
+                              "uint8"]))),
+               ("resize",) . showValue <$> (args !? #resize :: Maybe Int),
+               ("rand_crop",) . showValue <$> (args !? #rand_crop :: Maybe Bool),
+               ("random_resized_crop",) . showValue <$>
+                 (args !? #random_resized_crop :: Maybe Bool),
+               ("max_rotate_angle",) . showValue <$>
+                 (args !? #max_rotate_angle :: Maybe Int),
+               ("max_aspect_ratio",) . showValue <$>
+                 (args !? #max_aspect_ratio :: Maybe Float),
+               ("min_aspect_ratio",) . showValue <$>
+                 (args !? #min_aspect_ratio :: Maybe (Maybe Float)),
+               ("max_shear_ratio",) . showValue <$>
+                 (args !? #max_shear_ratio :: Maybe Float),
+               ("max_crop_size",) . showValue <$>
+                 (args !? #max_crop_size :: Maybe Int),
+               ("min_crop_size",) . showValue <$>
+                 (args !? #min_crop_size :: Maybe Int),
+               ("max_random_scale",) . showValue <$>
+                 (args !? #max_random_scale :: Maybe Float),
+               ("min_random_scale",) . showValue <$>
+                 (args !? #min_random_scale :: Maybe Float),
+               ("max_random_area",) . showValue <$>
+                 (args !? #max_random_area :: Maybe Float),
+               ("min_random_area",) . showValue <$>
+                 (args !? #min_random_area :: Maybe Float),
+               ("max_img_size",) . showValue <$>
+                 (args !? #max_img_size :: Maybe Float),
+               ("min_img_size",) . showValue <$>
+                 (args !? #min_img_size :: Maybe Float),
+               ("brightness",) . showValue <$>
+                 (args !? #brightness :: Maybe Float),
+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
+               ("saturation",) . showValue <$>
+                 (args !? #saturation :: Maybe Float),
+               ("pca_noise",) . showValue <$> (args !? #pca_noise :: Maybe Float),
+               ("random_h",) . showValue <$> (args !? #random_h :: Maybe Int),
+               ("random_s",) . showValue <$> (args !? #random_s :: Maybe Int),
+               ("random_l",) . showValue <$> (args !? #random_l :: Maybe Int),
+               ("rotate",) . showValue <$> (args !? #rotate :: Maybe Int),
+               ("fill_value",) . showValue <$> (args !? #fill_value :: Maybe Int),
+               ("data_shape",) . showValue <$>
+                 (args !? #data_shape :: Maybe [Int]),
+               ("inter_method",) . showValue <$>
+                 (args !? #inter_method :: Maybe Int),
+               ("pad",) . showValue <$> (args !? #pad :: Maybe Int),
+               ("seed",) . showValue <$> (args !? #seed :: Maybe Int),
+               ("mirror",) . showValue <$> (args !? #mirror :: Maybe Bool),
+               ("rand_mirror",) . showValue <$>
+                 (args !? #rand_mirror :: Maybe Bool),
+               ("mean_img",) . showValue <$> (args !? #mean_img :: Maybe Text),
+               ("mean_r",) . showValue <$> (args !? #mean_r :: Maybe Float),
+               ("mean_g",) . showValue <$> (args !? #mean_g :: Maybe Float),
+               ("mean_b",) . showValue <$> (args !? #mean_b :: Maybe Float),
+               ("mean_a",) . showValue <$> (args !? #mean_a :: Maybe Float),
+               ("std_r",) . showValue <$> (args !? #std_r :: Maybe Float),
+               ("std_g",) . showValue <$> (args !? #std_g :: Maybe Float),
+               ("std_b",) . showValue <$> (args !? #std_b :: Maybe Float),
+               ("std_a",) . showValue <$> (args !? #std_a :: Maybe Float),
+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
+               ("max_random_contrast",) . showValue <$>
+                 (args !? #max_random_contrast :: Maybe Float),
+               ("max_random_illumination",) . showValue <$>
+                 (args !? #max_random_illumination :: Maybe Float),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool)]
+        (keys, vals) = unzip allargs
+      in
+      do dis <- mxListDataIters
+         di <- return (dis !! 4)
+         mxDataIterCreateIter di keys vals
+
+type instance ParameterList "_ImageRecordUInt8Iter" dummy =
+     '[ '("path_imglist", AttrOpt Text), '("path_imgrec", AttrOpt Text),
+        '("path_imgidx", AttrOpt Text), '("aug_seq", AttrOpt Text),
+        '("label_width", AttrOpt Int), '("data_shape", AttrReq [Int]),
+        '("preprocess_threads", AttrOpt Int), '("verbose", AttrOpt Bool),
+        '("num_parts", AttrOpt Int), '("part_index", AttrOpt Int),
+        '("device_id", AttrOpt Int), '("shuffle_chunk_size", AttrOpt Int),
+        '("shuffle_chunk_seed", AttrOpt Int),
+        '("seed_aug", AttrOpt (Maybe Int)), '("shuffle", AttrOpt Bool),
+        '("seed", AttrOpt Int), '("verbose", AttrOpt Bool),
+        '("batch_size", AttrReq Int), '("round_batch", AttrOpt Bool),
+        '("prefetch_buffer", AttrOpt Int),
+        '("ctx", AttrOpt (EnumType '["cpu", "gpu"])),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["float16", "float32", "float64", "int32", "int64", "int8",
+                    "uint8"]))),
+        '("resize", AttrOpt Int), '("rand_crop", AttrOpt Bool),
+        '("random_resized_crop", AttrOpt Bool),
+        '("max_rotate_angle", AttrOpt Int),
+        '("max_aspect_ratio", AttrOpt Float),
+        '("min_aspect_ratio", AttrOpt (Maybe Float)),
+        '("max_shear_ratio", AttrOpt Float),
+        '("max_crop_size", AttrOpt Int), '("min_crop_size", AttrOpt Int),
+        '("max_random_scale", AttrOpt Float),
+        '("min_random_scale", AttrOpt Float),
+        '("max_random_area", AttrOpt Float),
+        '("min_random_area", AttrOpt Float),
+        '("max_img_size", AttrOpt Float), '("min_img_size", AttrOpt Float),
+        '("brightness", AttrOpt Float), '("contrast", AttrOpt Float),
+        '("saturation", AttrOpt Float), '("pca_noise", AttrOpt Float),
+        '("random_h", AttrOpt Int), '("random_s", AttrOpt Int),
+        '("random_l", AttrOpt Int), '("rotate", AttrOpt Int),
+        '("fill_value", AttrOpt Int), '("data_shape", AttrReq [Int]),
+        '("inter_method", AttrOpt Int), '("pad", AttrOpt Int)]
+
+_ImageRecordUInt8Iter ::
+                      forall a . Fullfilled "_ImageRecordUInt8Iter" () a =>
+                        ArgsHMap "_ImageRecordUInt8Iter" () a -> IO DataIterHandle
+_ImageRecordUInt8Iter args
+  = let allargs
+          = catMaybes
+              [("path_imglist",) . showValue <$>
+                 (args !? #path_imglist :: Maybe Text),
+               ("path_imgrec",) . showValue <$>
+                 (args !? #path_imgrec :: Maybe Text),
+               ("path_imgidx",) . showValue <$>
+                 (args !? #path_imgidx :: Maybe Text),
+               ("aug_seq",) . showValue <$> (args !? #aug_seq :: Maybe Text),
+               ("label_width",) . showValue <$>
+                 (args !? #label_width :: Maybe Int),
+               ("data_shape",) . showValue <$>
+                 (args !? #data_shape :: Maybe [Int]),
+               ("preprocess_threads",) . showValue <$>
+                 (args !? #preprocess_threads :: Maybe Int),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool),
+               ("num_parts",) . showValue <$> (args !? #num_parts :: Maybe Int),
+               ("part_index",) . showValue <$> (args !? #part_index :: Maybe Int),
+               ("device_id",) . showValue <$> (args !? #device_id :: Maybe Int),
+               ("shuffle_chunk_size",) . showValue <$>
+                 (args !? #shuffle_chunk_size :: Maybe Int),
+               ("shuffle_chunk_seed",) . showValue <$>
+                 (args !? #shuffle_chunk_seed :: Maybe Int),
+               ("seed_aug",) . showValue <$>
+                 (args !? #seed_aug :: Maybe (Maybe Int)),
+               ("shuffle",) . showValue <$> (args !? #shuffle :: Maybe Bool),
+               ("seed",) . showValue <$> (args !? #seed :: Maybe Int),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool),
+               ("batch_size",) . showValue <$> (args !? #batch_size :: Maybe Int),
+               ("round_batch",) . showValue <$>
+                 (args !? #round_batch :: Maybe Bool),
+               ("prefetch_buffer",) . showValue <$>
+                 (args !? #prefetch_buffer :: Maybe Int),
+               ("ctx",) . showValue <$>
+                 (args !? #ctx :: Maybe (EnumType '["cpu", "gpu"])),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["float16", "float32", "float64", "int32", "int64", "int8",
+                              "uint8"]))),
+               ("resize",) . showValue <$> (args !? #resize :: Maybe Int),
+               ("rand_crop",) . showValue <$> (args !? #rand_crop :: Maybe Bool),
+               ("random_resized_crop",) . showValue <$>
+                 (args !? #random_resized_crop :: Maybe Bool),
+               ("max_rotate_angle",) . showValue <$>
+                 (args !? #max_rotate_angle :: Maybe Int),
+               ("max_aspect_ratio",) . showValue <$>
+                 (args !? #max_aspect_ratio :: Maybe Float),
+               ("min_aspect_ratio",) . showValue <$>
+                 (args !? #min_aspect_ratio :: Maybe (Maybe Float)),
+               ("max_shear_ratio",) . showValue <$>
+                 (args !? #max_shear_ratio :: Maybe Float),
+               ("max_crop_size",) . showValue <$>
+                 (args !? #max_crop_size :: Maybe Int),
+               ("min_crop_size",) . showValue <$>
+                 (args !? #min_crop_size :: Maybe Int),
+               ("max_random_scale",) . showValue <$>
+                 (args !? #max_random_scale :: Maybe Float),
+               ("min_random_scale",) . showValue <$>
+                 (args !? #min_random_scale :: Maybe Float),
+               ("max_random_area",) . showValue <$>
+                 (args !? #max_random_area :: Maybe Float),
+               ("min_random_area",) . showValue <$>
+                 (args !? #min_random_area :: Maybe Float),
+               ("max_img_size",) . showValue <$>
+                 (args !? #max_img_size :: Maybe Float),
+               ("min_img_size",) . showValue <$>
+                 (args !? #min_img_size :: Maybe Float),
+               ("brightness",) . showValue <$>
+                 (args !? #brightness :: Maybe Float),
+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
+               ("saturation",) . showValue <$>
+                 (args !? #saturation :: Maybe Float),
+               ("pca_noise",) . showValue <$> (args !? #pca_noise :: Maybe Float),
+               ("random_h",) . showValue <$> (args !? #random_h :: Maybe Int),
+               ("random_s",) . showValue <$> (args !? #random_s :: Maybe Int),
+               ("random_l",) . showValue <$> (args !? #random_l :: Maybe Int),
+               ("rotate",) . showValue <$> (args !? #rotate :: Maybe Int),
+               ("fill_value",) . showValue <$> (args !? #fill_value :: Maybe Int),
+               ("data_shape",) . showValue <$>
+                 (args !? #data_shape :: Maybe [Int]),
+               ("inter_method",) . showValue <$>
+                 (args !? #inter_method :: Maybe Int),
+               ("pad",) . showValue <$> (args !? #pad :: Maybe Int)]
+        (keys, vals) = unzip allargs
+      in
+      do dis <- mxListDataIters
+         di <- return (dis !! 5)
+         mxDataIterCreateIter di keys vals
+
+type instance ParameterList "_ImageRecordInt8Iter" dummy =
+     '[ '("path_imglist", AttrOpt Text), '("path_imgrec", AttrOpt Text),
+        '("path_imgidx", AttrOpt Text), '("aug_seq", AttrOpt Text),
+        '("label_width", AttrOpt Int), '("data_shape", AttrReq [Int]),
+        '("preprocess_threads", AttrOpt Int), '("verbose", AttrOpt Bool),
+        '("num_parts", AttrOpt Int), '("part_index", AttrOpt Int),
+        '("device_id", AttrOpt Int), '("shuffle_chunk_size", AttrOpt Int),
+        '("shuffle_chunk_seed", AttrOpt Int),
+        '("seed_aug", AttrOpt (Maybe Int)), '("shuffle", AttrOpt Bool),
+        '("seed", AttrOpt Int), '("verbose", AttrOpt Bool),
+        '("batch_size", AttrReq Int), '("round_batch", AttrOpt Bool),
+        '("prefetch_buffer", AttrOpt Int),
+        '("ctx", AttrOpt (EnumType '["cpu", "gpu"])),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["float16", "float32", "float64", "int32", "int64", "int8",
+                    "uint8"]))),
+        '("resize", AttrOpt Int), '("rand_crop", AttrOpt Bool),
+        '("random_resized_crop", AttrOpt Bool),
+        '("max_rotate_angle", AttrOpt Int),
+        '("max_aspect_ratio", AttrOpt Float),
+        '("min_aspect_ratio", AttrOpt (Maybe Float)),
+        '("max_shear_ratio", AttrOpt Float),
+        '("max_crop_size", AttrOpt Int), '("min_crop_size", AttrOpt Int),
+        '("max_random_scale", AttrOpt Float),
+        '("min_random_scale", AttrOpt Float),
+        '("max_random_area", AttrOpt Float),
+        '("min_random_area", AttrOpt Float),
+        '("max_img_size", AttrOpt Float), '("min_img_size", AttrOpt Float),
+        '("brightness", AttrOpt Float), '("contrast", AttrOpt Float),
+        '("saturation", AttrOpt Float), '("pca_noise", AttrOpt Float),
+        '("random_h", AttrOpt Int), '("random_s", AttrOpt Int),
+        '("random_l", AttrOpt Int), '("rotate", AttrOpt Int),
+        '("fill_value", AttrOpt Int), '("data_shape", AttrReq [Int]),
+        '("inter_method", AttrOpt Int), '("pad", AttrOpt Int)]
+
+_ImageRecordInt8Iter ::
+                     forall a . Fullfilled "_ImageRecordInt8Iter" () a =>
+                       ArgsHMap "_ImageRecordInt8Iter" () a -> IO DataIterHandle
+_ImageRecordInt8Iter args
+  = let allargs
+          = catMaybes
+              [("path_imglist",) . showValue <$>
+                 (args !? #path_imglist :: Maybe Text),
+               ("path_imgrec",) . showValue <$>
+                 (args !? #path_imgrec :: Maybe Text),
+               ("path_imgidx",) . showValue <$>
+                 (args !? #path_imgidx :: Maybe Text),
+               ("aug_seq",) . showValue <$> (args !? #aug_seq :: Maybe Text),
+               ("label_width",) . showValue <$>
+                 (args !? #label_width :: Maybe Int),
+               ("data_shape",) . showValue <$>
+                 (args !? #data_shape :: Maybe [Int]),
+               ("preprocess_threads",) . showValue <$>
+                 (args !? #preprocess_threads :: Maybe Int),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool),
+               ("num_parts",) . showValue <$> (args !? #num_parts :: Maybe Int),
+               ("part_index",) . showValue <$> (args !? #part_index :: Maybe Int),
+               ("device_id",) . showValue <$> (args !? #device_id :: Maybe Int),
+               ("shuffle_chunk_size",) . showValue <$>
+                 (args !? #shuffle_chunk_size :: Maybe Int),
+               ("shuffle_chunk_seed",) . showValue <$>
+                 (args !? #shuffle_chunk_seed :: Maybe Int),
+               ("seed_aug",) . showValue <$>
+                 (args !? #seed_aug :: Maybe (Maybe Int)),
+               ("shuffle",) . showValue <$> (args !? #shuffle :: Maybe Bool),
+               ("seed",) . showValue <$> (args !? #seed :: Maybe Int),
+               ("verbose",) . showValue <$> (args !? #verbose :: Maybe Bool),
+               ("batch_size",) . showValue <$> (args !? #batch_size :: Maybe Int),
+               ("round_batch",) . showValue <$>
+                 (args !? #round_batch :: Maybe Bool),
+               ("prefetch_buffer",) . showValue <$>
+                 (args !? #prefetch_buffer :: Maybe Int),
+               ("ctx",) . showValue <$>
+                 (args !? #ctx :: Maybe (EnumType '["cpu", "gpu"])),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["float16", "float32", "float64", "int32", "int64", "int8",
+                              "uint8"]))),
+               ("resize",) . showValue <$> (args !? #resize :: Maybe Int),
+               ("rand_crop",) . showValue <$> (args !? #rand_crop :: Maybe Bool),
+               ("random_resized_crop",) . showValue <$>
+                 (args !? #random_resized_crop :: Maybe Bool),
+               ("max_rotate_angle",) . showValue <$>
+                 (args !? #max_rotate_angle :: Maybe Int),
+               ("max_aspect_ratio",) . showValue <$>
+                 (args !? #max_aspect_ratio :: Maybe Float),
+               ("min_aspect_ratio",) . showValue <$>
+                 (args !? #min_aspect_ratio :: Maybe (Maybe Float)),
+               ("max_shear_ratio",) . showValue <$>
+                 (args !? #max_shear_ratio :: Maybe Float),
+               ("max_crop_size",) . showValue <$>
+                 (args !? #max_crop_size :: Maybe Int),
+               ("min_crop_size",) . showValue <$>
+                 (args !? #min_crop_size :: Maybe Int),
+               ("max_random_scale",) . showValue <$>
+                 (args !? #max_random_scale :: Maybe Float),
+               ("min_random_scale",) . showValue <$>
+                 (args !? #min_random_scale :: Maybe Float),
+               ("max_random_area",) . showValue <$>
+                 (args !? #max_random_area :: Maybe Float),
+               ("min_random_area",) . showValue <$>
+                 (args !? #min_random_area :: Maybe Float),
+               ("max_img_size",) . showValue <$>
+                 (args !? #max_img_size :: Maybe Float),
+               ("min_img_size",) . showValue <$>
+                 (args !? #min_img_size :: Maybe Float),
+               ("brightness",) . showValue <$>
+                 (args !? #brightness :: Maybe Float),
+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
+               ("saturation",) . showValue <$>
+                 (args !? #saturation :: Maybe Float),
+               ("pca_noise",) . showValue <$> (args !? #pca_noise :: Maybe Float),
+               ("random_h",) . showValue <$> (args !? #random_h :: Maybe Int),
+               ("random_s",) . showValue <$> (args !? #random_s :: Maybe Int),
+               ("random_l",) . showValue <$> (args !? #random_l :: Maybe Int),
+               ("rotate",) . showValue <$> (args !? #rotate :: Maybe Int),
+               ("fill_value",) . showValue <$> (args !? #fill_value :: Maybe Int),
+               ("data_shape",) . showValue <$>
+                 (args !? #data_shape :: Maybe [Int]),
+               ("inter_method",) . showValue <$>
+                 (args !? #inter_method :: Maybe Int),
+               ("pad",) . showValue <$> (args !? #pad :: Maybe Int)]
+        (keys, vals) = unzip allargs
+      in
+      do dis <- mxListDataIters
+         di <- return (dis !! 6)
+         mxDataIterCreateIter di keys vals
+
+type instance ParameterList "_LibSVMIter" dummy =
+     '[ '("data_libsvm", AttrReq Text), '("data_shape", AttrReq [Int]),
+        '("label_libsvm", AttrOpt Text), '("label_shape", AttrOpt [Int]),
+        '("num_parts", AttrOpt Int), '("part_index", AttrOpt Int),
+        '("batch_size", AttrReq Int), '("round_batch", AttrOpt Bool),
+        '("prefetch_buffer", AttrOpt Int),
+        '("ctx", AttrOpt (EnumType '["cpu", "gpu"])),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["float16", "float32", "float64", "int32", "int64", "int8",
+                    "uint8"])))]
+
+_LibSVMIter ::
+            forall a . Fullfilled "_LibSVMIter" () a =>
+              ArgsHMap "_LibSVMIter" () a -> IO DataIterHandle
+_LibSVMIter args
+  = let allargs
+          = catMaybes
+              [("data_libsvm",) . showValue <$>
+                 (args !? #data_libsvm :: Maybe Text),
+               ("data_shape",) . showValue <$>
+                 (args !? #data_shape :: Maybe [Int]),
+               ("label_libsvm",) . showValue <$>
+                 (args !? #label_libsvm :: Maybe Text),
+               ("label_shape",) . showValue <$>
+                 (args !? #label_shape :: Maybe [Int]),
+               ("num_parts",) . showValue <$> (args !? #num_parts :: Maybe Int),
+               ("part_index",) . showValue <$> (args !? #part_index :: Maybe Int),
+               ("batch_size",) . showValue <$> (args !? #batch_size :: Maybe Int),
+               ("round_batch",) . showValue <$>
+                 (args !? #round_batch :: Maybe Bool),
+               ("prefetch_buffer",) . showValue <$>
+                 (args !? #prefetch_buffer :: Maybe Int),
+               ("ctx",) . showValue <$>
+                 (args !? #ctx :: Maybe (EnumType '["cpu", "gpu"])),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["float16", "float32", "float64", "int32", "int64", "int8",
+                              "uint8"])))]
+        (keys, vals) = unzip allargs
+      in
+      do dis <- mxListDataIters
+         di <- return (dis !! 7)
+         mxDataIterCreateIter di keys vals
+
+type instance ParameterList "_MNISTIter" dummy =
+     '[ '("image", AttrOpt Text), '("label", AttrOpt Text),
+        '("batch_size", AttrOpt Int), '("shuffle", AttrOpt Bool),
+        '("flat", AttrOpt Bool), '("seed", AttrOpt Int),
+        '("silent", AttrOpt Bool), '("num_parts", AttrOpt Int),
+        '("part_index", AttrOpt Int), '("prefetch_buffer", AttrOpt Int),
+        '("ctx", AttrOpt (EnumType '["cpu", "gpu"])),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["float16", "float32", "float64", "int32", "int64", "int8",
+                    "uint8"])))]
+
+_MNISTIter ::
+           forall a . Fullfilled "_MNISTIter" () a =>
+             ArgsHMap "_MNISTIter" () a -> IO DataIterHandle
+_MNISTIter args
+  = let allargs
+          = catMaybes
+              [("image",) . showValue <$> (args !? #image :: Maybe Text),
+               ("label",) . showValue <$> (args !? #label :: Maybe Text),
+               ("batch_size",) . showValue <$> (args !? #batch_size :: Maybe Int),
+               ("shuffle",) . showValue <$> (args !? #shuffle :: Maybe Bool),
+               ("flat",) . showValue <$> (args !? #flat :: Maybe Bool),
+               ("seed",) . showValue <$> (args !? #seed :: Maybe Int),
+               ("silent",) . showValue <$> (args !? #silent :: Maybe Bool),
+               ("num_parts",) . showValue <$> (args !? #num_parts :: Maybe Int),
+               ("part_index",) . showValue <$> (args !? #part_index :: Maybe Int),
+               ("prefetch_buffer",) . showValue <$>
+                 (args !? #prefetch_buffer :: Maybe Int),
+               ("ctx",) . showValue <$>
+                 (args !? #ctx :: Maybe (EnumType '["cpu", "gpu"])),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["float16", "float32", "float64", "int32", "int64", "int8",
+                              "uint8"])))]
+        (keys, vals) = unzip allargs
+      in
+      do dis <- mxListDataIters
+         di <- return (dis !! 8)
+         mxDataIterCreateIter di keys vals
diff --git a/ops/1.6/MXNet/Base/Operators/Tensor.hs b/ops/1.6/MXNet/Base/Operators/Tensor.hs
new file mode 100644
--- /dev/null
+++ b/ops/1.6/MXNet/Base/Operators/Tensor.hs
@@ -0,0 +1,14580 @@
+module MXNet.Base.Operators.Tensor where
+import RIO
+import RIO.List
+import MXNet.Base.Raw
+import MXNet.Base.Spec.Operator
+import MXNet.Base.Spec.HMap
+import MXNet.Base.Tensor
+import Data.Maybe (catMaybes, fromMaybe)
+
+type instance ParameterList "_Activation" t =
+     '[ '("act_type",
+          AttrReq
+            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),
+        '("data", AttrOpt t)]
+
+_Activation ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_Activation" t a, HasCallStack) =>
+              ArgsHMap "_Activation" t a -> TensorApply t
+_Activation args
+  = let scalarArgs
+          = catMaybes
+              [("act_type",) . showValue <$>
+                 (args !? #act_type ::
+                    Maybe
+                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "Activation" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_BatchNorm" t =
+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
+        '("cudnn_off", AttrOpt Bool),
+        '("min_calib_range", AttrOpt (Maybe Float)),
+        '("max_calib_range", AttrOpt (Maybe Float)), '("data", AttrOpt t),
+        '("gamma", AttrOpt t), '("beta", AttrOpt t),
+        '("moving_mean", AttrOpt t), '("moving_var", AttrOpt t)]
+
+_BatchNorm ::
+           forall a t .
+             (TensorOp t t, Fullfilled "_BatchNorm" t a, HasCallStack) =>
+             ArgsHMap "_BatchNorm" t a -> TensorApply t
+_BatchNorm args
+  = let scalarArgs
+          = catMaybes
+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
+               ("use_global_stats",) . showValue <$>
+                 (args !? #use_global_stats :: Maybe Bool),
+               ("output_mean_var",) . showValue <$>
+                 (args !? #output_mean_var :: Maybe Bool),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
+               ("min_calib_range",) . showValue <$>
+                 (args !? #min_calib_range :: Maybe (Maybe Float)),
+               ("max_calib_range",) . showValue <$>
+                 (args !? #max_calib_range :: Maybe (Maybe Float))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("gamma",) <$> (args !? #gamma :: Maybe t),
+               ("beta",) <$> (args !? #beta :: Maybe t),
+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe t),
+               ("moving_var",) <$> (args !? #moving_var :: Maybe t)]
+      in
+      apply "BatchNorm" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_BatchNorm_v1" t =
+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
+        '("output_mean_var", AttrOpt Bool), '("data", AttrOpt t),
+        '("gamma", AttrOpt t), '("beta", AttrOpt t)]
+
+_BatchNorm_v1 ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_BatchNorm_v1" t a, HasCallStack) =>
+                ArgsHMap "_BatchNorm_v1" t a -> TensorApply t
+_BatchNorm_v1 args
+  = let scalarArgs
+          = catMaybes
+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
+               ("use_global_stats",) . showValue <$>
+                 (args !? #use_global_stats :: Maybe Bool),
+               ("output_mean_var",) . showValue <$>
+                 (args !? #output_mean_var :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("gamma",) <$> (args !? #gamma :: Maybe t),
+               ("beta",) <$> (args !? #beta :: Maybe t)]
+      in
+      apply "BatchNorm_v1" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_BilinearSampler" t =
+     '[ '("cudnn_off", AttrOpt (Maybe Bool)), '("data", AttrOpt t),
+        '("grid", AttrOpt t)]
+
+_BilinearSampler ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "_BilinearSampler" t a, HasCallStack) =>
+                   ArgsHMap "_BilinearSampler" t a -> TensorApply t
+_BilinearSampler args
+  = let scalarArgs
+          = catMaybes
+              [("cudnn_off",) . showValue <$>
+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("grid",) <$> (args !? #grid :: Maybe t)]
+      in
+      apply "BilinearSampler" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_BlockGrad" t =
+     '[ '("data", AttrOpt t)]
+
+_BlockGrad ::
+           forall a t .
+             (TensorOp t t, Fullfilled "_BlockGrad" t a, HasCallStack) =>
+             ArgsHMap "_BlockGrad" t a -> TensorApply t
+_BlockGrad args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "BlockGrad" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_CTCLoss" t =
+     '[ '("use_data_lengths", AttrOpt Bool),
+        '("use_label_lengths", AttrOpt Bool),
+        '("blank_label", AttrOpt (EnumType '["first", "last"])),
+        '("data", AttrOpt t), '("label", AttrOpt t),
+        '("data_lengths", AttrOpt t), '("label_lengths", AttrOpt t)]
+
+_CTCLoss ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_CTCLoss" t a, HasCallStack) =>
+           ArgsHMap "_CTCLoss" t a -> TensorApply t
+_CTCLoss args
+  = let scalarArgs
+          = catMaybes
+              [("use_data_lengths",) . showValue <$>
+                 (args !? #use_data_lengths :: Maybe Bool),
+               ("use_label_lengths",) . showValue <$>
+                 (args !? #use_label_lengths :: Maybe Bool),
+               ("blank_label",) . showValue <$>
+                 (args !? #blank_label :: Maybe (EnumType '["first", "last"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("label",) <$> (args !? #label :: Maybe t),
+               ("data_lengths",) <$> (args !? #data_lengths :: Maybe t),
+               ("label_lengths",) <$> (args !? #label_lengths :: Maybe t)]
+      in apply "CTCLoss" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_Cast" t =
+     '[ '("dtype",
+          AttrReq
+            (EnumType
+               '["bool", "float16", "float32", "float64", "int32", "int64",
+                 "int8", "uint8"])),
+        '("data", AttrOpt t)]
+
+_Cast ::
+      forall a t o .
+        (TensorOp t o, Fullfilled "_Cast" t a, HasCallStack) =>
+        ArgsHMap "_Cast" t a -> TensorApply o
+_Cast args
+  = let scalarArgs
+          = catMaybes
+              [("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["bool", "float16", "float32", "float64", "int32", "int64",
+                           "int8", "uint8"]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "Cast" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_Concat" t =
+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+_Concat ::
+        forall a t .
+          (TensorOp t t, Fullfilled "_Concat" t a, HasCallStack) =>
+          ArgsHMap "_Concat" t a -> TensorApply t
+_Concat args
+  = let scalarArgs
+          = catMaybes
+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "Concat" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_Convolution" t =
+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
+        '("cudnn_tune",
+          AttrOpt
+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
+        '("cudnn_off", AttrOpt Bool),
+        '("layout",
+          AttrOpt
+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
+        '("data", AttrOpt t), '("weight", AttrOpt t), '("bias", AttrOpt t)]
+
+_Convolution ::
+             forall a t .
+               (TensorOp t t, Fullfilled "_Convolution" t a, HasCallStack) =>
+               ArgsHMap "_Convolution" t a -> TensorApply t
+_Convolution args
+  = let scalarArgs
+          = catMaybes
+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
+               ("cudnn_tune",) . showValue <$>
+                 (args !? #cudnn_tune ::
+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
+               ("layout",) . showValue <$>
+                 (args !? #layout ::
+                    Maybe
+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("weight",) <$> (args !? #weight :: Maybe t),
+               ("bias",) <$> (args !? #bias :: Maybe t)]
+      in
+      apply "Convolution" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_Convolution_v1" t =
+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
+        '("cudnn_tune",
+          AttrOpt
+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
+        '("cudnn_off", AttrOpt Bool),
+        '("layout",
+          AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"]))),
+        '("data", AttrOpt t), '("weight", AttrOpt t), '("bias", AttrOpt t)]
+
+_Convolution_v1 ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "_Convolution_v1" t a, HasCallStack) =>
+                  ArgsHMap "_Convolution_v1" t a -> TensorApply t
+_Convolution_v1 args
+  = let scalarArgs
+          = catMaybes
+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
+               ("cudnn_tune",) . showValue <$>
+                 (args !? #cudnn_tune ::
+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
+               ("layout",) . showValue <$>
+                 (args !? #layout ::
+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NDHWC", "NHWC"])))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("weight",) <$> (args !? #weight :: Maybe t),
+               ("bias",) <$> (args !? #bias :: Maybe t)]
+      in
+      apply "Convolution_v1" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_Correlation" t =
+     '[ '("kernel_size", AttrOpt Int),
+        '("max_displacement", AttrOpt Int), '("stride1", AttrOpt Int),
+        '("stride2", AttrOpt Int), '("pad_size", AttrOpt Int),
+        '("is_multiply", AttrOpt Bool), '("data1", AttrOpt t),
+        '("data2", AttrOpt t)]
+
+_Correlation ::
+             forall a t .
+               (TensorOp t t, Fullfilled "_Correlation" t a, HasCallStack) =>
+               ArgsHMap "_Correlation" t a -> TensorApply t
+_Correlation args
+  = let scalarArgs
+          = catMaybes
+              [("kernel_size",) . showValue <$>
+                 (args !? #kernel_size :: Maybe Int),
+               ("max_displacement",) . showValue <$>
+                 (args !? #max_displacement :: Maybe Int),
+               ("stride1",) . showValue <$> (args !? #stride1 :: Maybe Int),
+               ("stride2",) . showValue <$> (args !? #stride2 :: Maybe Int),
+               ("pad_size",) . showValue <$> (args !? #pad_size :: Maybe Int),
+               ("is_multiply",) . showValue <$>
+                 (args !? #is_multiply :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("data1",) <$> (args !? #data1 :: Maybe t),
+               ("data2",) <$> (args !? #data2 :: Maybe t)]
+      in
+      apply "Correlation" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_Crop" t =
+     '[ '("num_args", AttrReq Int), '("offset", AttrOpt [Int]),
+        '("h_w", AttrOpt [Int]), '("center_crop", AttrOpt Bool),
+        '("data", AttrOpt [t])]
+
+_Crop ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_Crop" t a, HasCallStack) =>
+        ArgsHMap "_Crop" t a -> TensorApply t
+_Crop args
+  = let scalarArgs
+          = catMaybes
+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
+               ("offset",) . showValue <$> (args !? #offset :: Maybe [Int]),
+               ("h_w",) . showValue <$> (args !? #h_w :: Maybe [Int]),
+               ("center_crop",) . showValue <$>
+                 (args !? #center_crop :: Maybe Bool)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "Crop" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_CuDNNBatchNorm" t =
+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
+        '("cudnn_off", AttrOpt Bool),
+        '("min_calib_range", AttrOpt (Maybe Float)),
+        '("max_calib_range", AttrOpt (Maybe Float)), '("data", AttrOpt t),
+        '("gamma", AttrOpt t), '("beta", AttrOpt t),
+        '("moving_mean", AttrOpt t), '("moving_var", AttrOpt t)]
+
+_CuDNNBatchNorm ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "_CuDNNBatchNorm" t a, HasCallStack) =>
+                  ArgsHMap "_CuDNNBatchNorm" t a -> TensorApply t
+_CuDNNBatchNorm args
+  = let scalarArgs
+          = catMaybes
+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
+               ("use_global_stats",) . showValue <$>
+                 (args !? #use_global_stats :: Maybe Bool),
+               ("output_mean_var",) . showValue <$>
+                 (args !? #output_mean_var :: Maybe Bool),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
+               ("min_calib_range",) . showValue <$>
+                 (args !? #min_calib_range :: Maybe (Maybe Float)),
+               ("max_calib_range",) . showValue <$>
+                 (args !? #max_calib_range :: Maybe (Maybe Float))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("gamma",) <$> (args !? #gamma :: Maybe t),
+               ("beta",) <$> (args !? #beta :: Maybe t),
+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe t),
+               ("moving_var",) <$> (args !? #moving_var :: Maybe t)]
+      in
+      apply "CuDNNBatchNorm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_Custom" t =
+     '[ '("op_type", AttrOpt Text), '("data", AttrOpt [t])]
+
+_Custom ::
+        forall a t .
+          (TensorOp t t, Fullfilled "_Custom" t a, HasCallStack,
+           PopKey (ArgOf "_Custom" t) a "data",
+           Dump (PopResult (ArgOf "_Custom" t) a "data")) =>
+          ArgsHMap "_Custom" t a -> TensorApply t
+_Custom args
+  = let scalarArgs = dump (pop args #data)
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "Custom" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_Deconvolution" t =
+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
+        '("adj", AttrOpt [Int]), '("target_shape", AttrOpt [Int]),
+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
+        '("cudnn_tune",
+          AttrOpt
+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
+        '("cudnn_off", AttrOpt Bool),
+        '("layout",
+          AttrOpt
+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
+        '("data", AttrOpt t), '("weight", AttrOpt t), '("bias", AttrOpt t)]
+
+_Deconvolution ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "_Deconvolution" t a, HasCallStack) =>
+                 ArgsHMap "_Deconvolution" t a -> TensorApply t
+_Deconvolution args
+  = let scalarArgs
+          = catMaybes
+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
+               ("adj",) . showValue <$> (args !? #adj :: Maybe [Int]),
+               ("target_shape",) . showValue <$>
+                 (args !? #target_shape :: Maybe [Int]),
+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
+               ("cudnn_tune",) . showValue <$>
+                 (args !? #cudnn_tune ::
+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
+               ("layout",) . showValue <$>
+                 (args !? #layout ::
+                    Maybe
+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("weight",) <$> (args !? #weight :: Maybe t),
+               ("bias",) <$> (args !? #bias :: Maybe t)]
+      in
+      apply "Deconvolution" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_Dropout" t =
+     '[ '("p", AttrOpt Float),
+        '("mode", AttrOpt (EnumType '["always", "training"])),
+        '("axes", AttrOpt [Int]), '("cudnn_off", AttrOpt (Maybe Bool)),
+        '("data", AttrOpt t)]
+
+_Dropout ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_Dropout" t a, HasCallStack) =>
+           ArgsHMap "_Dropout" t a -> TensorApply t
+_Dropout args
+  = let scalarArgs
+          = catMaybes
+              [("p",) . showValue <$> (args !? #p :: Maybe Float),
+               ("mode",) . showValue <$>
+                 (args !? #mode :: Maybe (EnumType '["always", "training"])),
+               ("axes",) . showValue <$> (args !? #axes :: Maybe [Int]),
+               ("cudnn_off",) . showValue <$>
+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "Dropout" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_Embedding" t =
+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "int8",
+                 "uint8"])),
+        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt t),
+        '("weight", AttrOpt t)]
+
+_Embedding ::
+           forall a t .
+             (TensorOp t t, Fullfilled "_Embedding" t a, HasCallStack) =>
+             ArgsHMap "_Embedding" t a -> TensorApply t
+_Embedding args
+  = let scalarArgs
+          = catMaybes
+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "int8",
+                           "uint8"])),
+               ("sparse_grad",) . showValue <$>
+                 (args !? #sparse_grad :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("weight",) <$> (args !? #weight :: Maybe t)]
+      in
+      apply "Embedding" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_Flatten" t = '[ '("data", AttrOpt t)]
+
+_Flatten ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_Flatten" t a, HasCallStack) =>
+           ArgsHMap "_Flatten" t a -> TensorApply t
+_Flatten args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "Flatten" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_FullyConnected" t =
+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
+        '("flatten", AttrOpt Bool), '("data", AttrOpt t),
+        '("weight", AttrOpt t), '("bias", AttrOpt t)]
+
+_FullyConnected ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "_FullyConnected" t a, HasCallStack) =>
+                  ArgsHMap "_FullyConnected" t a -> TensorApply t
+_FullyConnected args
+  = let scalarArgs
+          = catMaybes
+              [("num_hidden",) . showValue <$>
+                 (args !? #num_hidden :: Maybe Int),
+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("weight",) <$> (args !? #weight :: Maybe t),
+               ("bias",) <$> (args !? #bias :: Maybe t)]
+      in
+      apply "FullyConnected" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_GridGenerator" t =
+     '[ '("transform_type", AttrReq (EnumType '["affine", "warp"])),
+        '("target_shape", AttrOpt [Int]), '("data", AttrOpt t)]
+
+_GridGenerator ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "_GridGenerator" t a, HasCallStack) =>
+                 ArgsHMap "_GridGenerator" t a -> TensorApply t
+_GridGenerator args
+  = let scalarArgs
+          = catMaybes
+              [("transform_type",) . showValue <$>
+                 (args !? #transform_type :: Maybe (EnumType '["affine", "warp"])),
+               ("target_shape",) . showValue <$>
+                 (args !? #target_shape :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "GridGenerator" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_GroupNorm" t =
+     '[ '("num_groups", AttrOpt Int), '("eps", AttrOpt Float),
+        '("output_mean_var", AttrOpt Bool), '("data", AttrOpt t),
+        '("gamma", AttrOpt t), '("beta", AttrOpt t)]
+
+_GroupNorm ::
+           forall a t .
+             (TensorOp t t, Fullfilled "_GroupNorm" t a, HasCallStack) =>
+             ArgsHMap "_GroupNorm" t a -> TensorApply t
+_GroupNorm args
+  = let scalarArgs
+          = catMaybes
+              [("num_groups",) . showValue <$>
+                 (args !? #num_groups :: Maybe Int),
+               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),
+               ("output_mean_var",) . showValue <$>
+                 (args !? #output_mean_var :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("gamma",) <$> (args !? #gamma :: Maybe t),
+               ("beta",) <$> (args !? #beta :: Maybe t)]
+      in
+      apply "GroupNorm" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_IdentityAttachKLSparseReg" t =
+     '[ '("sparseness_target", AttrOpt Float),
+        '("penalty", AttrOpt Float), '("momentum", AttrOpt Float),
+        '("data", AttrOpt t)]
+
+_IdentityAttachKLSparseReg ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "_IdentityAttachKLSparseReg" t a,
+                              HasCallStack) =>
+                             ArgsHMap "_IdentityAttachKLSparseReg" t a -> TensorApply t
+_IdentityAttachKLSparseReg args
+  = let scalarArgs
+          = catMaybes
+              [("sparseness_target",) . showValue <$>
+                 (args !? #sparseness_target :: Maybe Float),
+               ("penalty",) . showValue <$> (args !? #penalty :: Maybe Float),
+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "IdentityAttachKLSparseReg" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_InstanceNorm" t =
+     '[ '("eps", AttrOpt Float), '("data", AttrOpt t),
+        '("gamma", AttrOpt t), '("beta", AttrOpt t)]
+
+_InstanceNorm ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_InstanceNorm" t a, HasCallStack) =>
+                ArgsHMap "_InstanceNorm" t a -> TensorApply t
+_InstanceNorm args
+  = let scalarArgs
+          = catMaybes
+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("gamma",) <$> (args !? #gamma :: Maybe t),
+               ("beta",) <$> (args !? #beta :: Maybe t)]
+      in
+      apply "InstanceNorm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_L2Normalization" t =
+     '[ '("eps", AttrOpt Float),
+        '("mode", AttrOpt (EnumType '["channel", "instance", "spatial"])),
+        '("data", AttrOpt t)]
+
+_L2Normalization ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "_L2Normalization" t a, HasCallStack) =>
+                   ArgsHMap "_L2Normalization" t a -> TensorApply t
+_L2Normalization args
+  = let scalarArgs
+          = catMaybes
+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
+               ("mode",) . showValue <$>
+                 (args !? #mode ::
+                    Maybe (EnumType '["channel", "instance", "spatial"]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "L2Normalization" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_LRN" t =
+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
+        '("knorm", AttrOpt Float), '("nsize", AttrReq Int),
+        '("data", AttrOpt t)]
+
+_LRN ::
+     forall a t . (TensorOp t t, Fullfilled "_LRN" t a, HasCallStack) =>
+       ArgsHMap "_LRN" t a -> TensorApply t
+_LRN args
+  = let scalarArgs
+          = catMaybes
+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
+               ("knorm",) . showValue <$> (args !? #knorm :: Maybe Float),
+               ("nsize",) . showValue <$> (args !? #nsize :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "LRN" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_LayerNorm" t =
+     '[ '("axis", AttrOpt Int), '("eps", AttrOpt Float),
+        '("output_mean_var", AttrOpt Bool), '("data", AttrOpt t),
+        '("gamma", AttrOpt t), '("beta", AttrOpt t)]
+
+_LayerNorm ::
+           forall a t .
+             (TensorOp t t, Fullfilled "_LayerNorm" t a, HasCallStack) =>
+             ArgsHMap "_LayerNorm" t a -> TensorApply t
+_LayerNorm args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
+               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),
+               ("output_mean_var",) . showValue <$>
+                 (args !? #output_mean_var :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("gamma",) <$> (args !? #gamma :: Maybe t),
+               ("beta",) <$> (args !? #beta :: Maybe t)]
+      in
+      apply "LayerNorm" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_LeakyReLU" t =
+     '[ '("act_type",
+          AttrOpt
+            (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])),
+        '("slope", AttrOpt Float), '("lower_bound", AttrOpt Float),
+        '("upper_bound", AttrOpt Float), '("data", AttrOpt t),
+        '("gamma", AttrOpt t)]
+
+_LeakyReLU ::
+           forall a t .
+             (TensorOp t t, Fullfilled "_LeakyReLU" t a, HasCallStack) =>
+             ArgsHMap "_LeakyReLU" t a -> TensorApply t
+_LeakyReLU args
+  = let scalarArgs
+          = catMaybes
+              [("act_type",) . showValue <$>
+                 (args !? #act_type ::
+                    Maybe
+                      (EnumType '["elu", "gelu", "leaky", "prelu", "rrelu", "selu"])),
+               ("slope",) . showValue <$> (args !? #slope :: Maybe Float),
+               ("lower_bound",) . showValue <$>
+                 (args !? #lower_bound :: Maybe Float),
+               ("upper_bound",) . showValue <$>
+                 (args !? #upper_bound :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("gamma",) <$> (args !? #gamma :: Maybe t)]
+      in
+      apply "LeakyReLU" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_LinearRegressionOutput" t =
+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt t),
+        '("label", AttrOpt t)]
+
+_LinearRegressionOutput ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "_LinearRegressionOutput" t a,
+                           HasCallStack) =>
+                          ArgsHMap "_LinearRegressionOutput" t a -> TensorApply t
+_LinearRegressionOutput args
+  = let scalarArgs
+          = catMaybes
+              [("grad_scale",) . showValue <$>
+                 (args !? #grad_scale :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("label",) <$> (args !? #label :: Maybe t)]
+      in
+      apply "LinearRegressionOutput" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_LogisticRegressionOutput" t =
+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt t),
+        '("label", AttrOpt t)]
+
+_LogisticRegressionOutput ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "_LogisticRegressionOutput" t a,
+                             HasCallStack) =>
+                            ArgsHMap "_LogisticRegressionOutput" t a -> TensorApply t
+_LogisticRegressionOutput args
+  = let scalarArgs
+          = catMaybes
+              [("grad_scale",) . showValue <$>
+                 (args !? #grad_scale :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("label",) <$> (args !? #label :: Maybe t)]
+      in
+      apply "LogisticRegressionOutput" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_MAERegressionOutput" t =
+     '[ '("grad_scale", AttrOpt Float), '("data", AttrOpt t),
+        '("label", AttrOpt t)]
+
+_MAERegressionOutput ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "_MAERegressionOutput" t a,
+                        HasCallStack) =>
+                       ArgsHMap "_MAERegressionOutput" t a -> TensorApply t
+_MAERegressionOutput args
+  = let scalarArgs
+          = catMaybes
+              [("grad_scale",) . showValue <$>
+                 (args !? #grad_scale :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("label",) <$> (args !? #label :: Maybe t)]
+      in
+      apply "MAERegressionOutput" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_MakeLoss" t =
+     '[ '("grad_scale", AttrOpt Float),
+        '("valid_thresh", AttrOpt Float),
+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
+        '("data", AttrOpt t)]
+
+_MakeLoss ::
+          forall a t .
+            (TensorOp t t, Fullfilled "_MakeLoss" t a, HasCallStack) =>
+            ArgsHMap "_MakeLoss" t a -> TensorApply t
+_MakeLoss args
+  = let scalarArgs
+          = catMaybes
+              [("grad_scale",) . showValue <$>
+                 (args !? #grad_scale :: Maybe Float),
+               ("valid_thresh",) . showValue <$>
+                 (args !? #valid_thresh :: Maybe Float),
+               ("normalization",) . showValue <$>
+                 (args !? #normalization ::
+                    Maybe (EnumType '["batch", "null", "valid"]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "MakeLoss" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_Pad" t =
+     '[ '("mode", AttrReq (EnumType '["constant", "edge", "reflect"])),
+        '("pad_width", AttrReq [Int]), '("constant_value", AttrOpt Double),
+        '("data", AttrOpt t)]
+
+_Pad ::
+     forall a t . (TensorOp t t, Fullfilled "_Pad" t a, HasCallStack) =>
+       ArgsHMap "_Pad" t a -> TensorApply t
+_Pad args
+  = let scalarArgs
+          = catMaybes
+              [("mode",) . showValue <$>
+                 (args !? #mode ::
+                    Maybe (EnumType '["constant", "edge", "reflect"])),
+               ("pad_width",) . showValue <$> (args !? #pad_width :: Maybe [Int]),
+               ("constant_value",) . showValue <$>
+                 (args !? #constant_value :: Maybe Double)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "Pad" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_Pooling" t =
+     '[ '("kernel", AttrOpt [Int]),
+        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),
+        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
+        '("pooling_convention",
+          AttrOpt (EnumType '["full", "same", "valid"])),
+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
+        '("p_value", AttrOpt (Maybe Int)),
+        '("count_include_pad", AttrOpt (Maybe Bool)),
+        '("layout",
+          AttrOpt
+            (Maybe
+               (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"]))),
+        '("data", AttrOpt t)]
+
+_Pooling ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_Pooling" t a, HasCallStack) =>
+           ArgsHMap "_Pooling" t a -> TensorApply t
+_Pooling args
+  = let scalarArgs
+          = catMaybes
+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
+               ("pool_type",) . showValue <$>
+                 (args !? #pool_type ::
+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
+               ("global_pool",) . showValue <$>
+                 (args !? #global_pool :: Maybe Bool),
+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
+               ("pooling_convention",) . showValue <$>
+                 (args !? #pooling_convention ::
+                    Maybe (EnumType '["full", "same", "valid"])),
+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
+               ("p_value",) . showValue <$>
+                 (args !? #p_value :: Maybe (Maybe Int)),
+               ("count_include_pad",) . showValue <$>
+                 (args !? #count_include_pad :: Maybe (Maybe Bool)),
+               ("layout",) . showValue <$>
+                 (args !? #layout ::
+                    Maybe
+                      (Maybe
+                         (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "Pooling" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_Pooling_v1" t =
+     '[ '("kernel", AttrOpt [Int]),
+        '("pool_type", AttrOpt (EnumType '["avg", "max", "sum"])),
+        '("global_pool", AttrOpt Bool),
+        '("pooling_convention", AttrOpt (EnumType '["full", "valid"])),
+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
+        '("data", AttrOpt t)]
+
+_Pooling_v1 ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_Pooling_v1" t a, HasCallStack) =>
+              ArgsHMap "_Pooling_v1" t a -> TensorApply t
+_Pooling_v1 args
+  = let scalarArgs
+          = catMaybes
+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
+               ("pool_type",) . showValue <$>
+                 (args !? #pool_type :: Maybe (EnumType '["avg", "max", "sum"])),
+               ("global_pool",) . showValue <$>
+                 (args !? #global_pool :: Maybe Bool),
+               ("pooling_convention",) . showValue <$>
+                 (args !? #pooling_convention ::
+                    Maybe (EnumType '["full", "valid"])),
+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "Pooling_v1" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_RNN" t =
+     '[ '("state_size", AttrReq Int), '("num_layers", AttrReq Int),
+        '("bidirectional", AttrOpt Bool),
+        '("mode",
+          AttrReq (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
+        '("p", AttrOpt Float), '("state_outputs", AttrOpt Bool),
+        '("projection_size", AttrOpt (Maybe Int)),
+        '("lstm_state_clip_min", AttrOpt (Maybe Double)),
+        '("lstm_state_clip_max", AttrOpt (Maybe Double)),
+        '("lstm_state_clip_nan", AttrOpt Bool),
+        '("use_sequence_length", AttrOpt Bool), '("data", AttrOpt t),
+        '("parameters", AttrOpt t), '("state", AttrOpt t),
+        '("state_cell", AttrOpt t), '("sequence_length", AttrOpt t)]
+
+_RNN ::
+     forall a t . (TensorOp t t, Fullfilled "_RNN" t a, HasCallStack) =>
+       ArgsHMap "_RNN" t a -> TensorApply t
+_RNN args
+  = let scalarArgs
+          = catMaybes
+              [("state_size",) . showValue <$>
+                 (args !? #state_size :: Maybe Int),
+               ("num_layers",) . showValue <$> (args !? #num_layers :: Maybe Int),
+               ("bidirectional",) . showValue <$>
+                 (args !? #bidirectional :: Maybe Bool),
+               ("mode",) . showValue <$>
+                 (args !? #mode ::
+                    Maybe (EnumType '["gru", "lstm", "rnn_relu", "rnn_tanh"])),
+               ("p",) . showValue <$> (args !? #p :: Maybe Float),
+               ("state_outputs",) . showValue <$>
+                 (args !? #state_outputs :: Maybe Bool),
+               ("projection_size",) . showValue <$>
+                 (args !? #projection_size :: Maybe (Maybe Int)),
+               ("lstm_state_clip_min",) . showValue <$>
+                 (args !? #lstm_state_clip_min :: Maybe (Maybe Double)),
+               ("lstm_state_clip_max",) . showValue <$>
+                 (args !? #lstm_state_clip_max :: Maybe (Maybe Double)),
+               ("lstm_state_clip_nan",) . showValue <$>
+                 (args !? #lstm_state_clip_nan :: Maybe Bool),
+               ("use_sequence_length",) . showValue <$>
+                 (args !? #use_sequence_length :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("parameters",) <$> (args !? #parameters :: Maybe t),
+               ("state",) <$> (args !? #state :: Maybe t),
+               ("state_cell",) <$> (args !? #state_cell :: Maybe t),
+               ("sequence_length",) <$> (args !? #sequence_length :: Maybe t)]
+      in apply "RNN" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_ROIPooling" t =
+     '[ '("pooled_size", AttrReq [Int]),
+        '("spatial_scale", AttrReq Float), '("data", AttrOpt t),
+        '("rois", AttrOpt t)]
+
+_ROIPooling ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_ROIPooling" t a, HasCallStack) =>
+              ArgsHMap "_ROIPooling" t a -> TensorApply t
+_ROIPooling args
+  = let scalarArgs
+          = catMaybes
+              [("pooled_size",) . showValue <$>
+                 (args !? #pooled_size :: Maybe [Int]),
+               ("spatial_scale",) . showValue <$>
+                 (args !? #spatial_scale :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("rois",) <$> (args !? #rois :: Maybe t)]
+      in
+      apply "ROIPooling" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_Reshape" t =
+     '[ '("shape", AttrOpt [Int]), '("reverse", AttrOpt Bool),
+        '("target_shape", AttrOpt [Int]), '("keep_highest", AttrOpt Bool),
+        '("data", AttrOpt t)]
+
+_Reshape ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_Reshape" t a, HasCallStack) =>
+           ArgsHMap "_Reshape" t a -> TensorApply t
+_Reshape args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),
+               ("target_shape",) . showValue <$>
+                 (args !? #target_shape :: Maybe [Int]),
+               ("keep_highest",) . showValue <$>
+                 (args !? #keep_highest :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "Reshape" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_SVMOutput" t =
+     '[ '("margin", AttrOpt Float),
+        '("regularization_coefficient", AttrOpt Float),
+        '("use_linear", AttrOpt Bool), '("data", AttrOpt t),
+        '("label", AttrOpt t)]
+
+_SVMOutput ::
+           forall a t .
+             (TensorOp t t, Fullfilled "_SVMOutput" t a, HasCallStack) =>
+             ArgsHMap "_SVMOutput" t a -> TensorApply t
+_SVMOutput args
+  = let scalarArgs
+          = catMaybes
+              [("margin",) . showValue <$> (args !? #margin :: Maybe Float),
+               ("regularization_coefficient",) . showValue <$>
+                 (args !? #regularization_coefficient :: Maybe Float),
+               ("use_linear",) . showValue <$>
+                 (args !? #use_linear :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("label",) <$> (args !? #label :: Maybe t)]
+      in
+      apply "SVMOutput" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_SequenceLast" t =
+     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),
+        '("data", AttrOpt t), '("sequence_length", AttrOpt t)]
+
+_SequenceLast ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_SequenceLast" t a, HasCallStack) =>
+                ArgsHMap "_SequenceLast" t a -> TensorApply t
+_SequenceLast args
+  = let scalarArgs
+          = catMaybes
+              [("use_sequence_length",) . showValue <$>
+                 (args !? #use_sequence_length :: Maybe Bool),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("sequence_length",) <$> (args !? #sequence_length :: Maybe t)]
+      in
+      apply "SequenceLast" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_SequenceMask" t =
+     '[ '("use_sequence_length", AttrOpt Bool),
+        '("value", AttrOpt Float), '("axis", AttrOpt Int),
+        '("data", AttrOpt t), '("sequence_length", AttrOpt t)]
+
+_SequenceMask ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_SequenceMask" t a, HasCallStack) =>
+                ArgsHMap "_SequenceMask" t a -> TensorApply t
+_SequenceMask args
+  = let scalarArgs
+          = catMaybes
+              [("use_sequence_length",) . showValue <$>
+                 (args !? #use_sequence_length :: Maybe Bool),
+               ("value",) . showValue <$> (args !? #value :: Maybe Float),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("sequence_length",) <$> (args !? #sequence_length :: Maybe t)]
+      in
+      apply "SequenceMask" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_SequenceReverse" t =
+     '[ '("use_sequence_length", AttrOpt Bool), '("axis", AttrOpt Int),
+        '("data", AttrOpt t), '("sequence_length", AttrOpt t)]
+
+_SequenceReverse ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "_SequenceReverse" t a, HasCallStack) =>
+                   ArgsHMap "_SequenceReverse" t a -> TensorApply t
+_SequenceReverse args
+  = let scalarArgs
+          = catMaybes
+              [("use_sequence_length",) . showValue <$>
+                 (args !? #use_sequence_length :: Maybe Bool),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("sequence_length",) <$> (args !? #sequence_length :: Maybe t)]
+      in
+      apply "SequenceReverse" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_SliceChannel" t =
+     '[ '("num_outputs", AttrReq Int), '("axis", AttrOpt Int),
+        '("squeeze_axis", AttrOpt Bool), '("data", AttrOpt t)]
+
+_SliceChannel ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_SliceChannel" t a, HasCallStack) =>
+                ArgsHMap "_SliceChannel" t a -> TensorApply t
+_SliceChannel args
+  = let scalarArgs
+          = catMaybes
+              [("num_outputs",) . showValue <$>
+                 (args !? #num_outputs :: Maybe Int),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
+               ("squeeze_axis",) . showValue <$>
+                 (args !? #squeeze_axis :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "SliceChannel" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_SoftmaxActivation" t =
+     '[ '("mode", AttrOpt (EnumType '["channel", "instance"])),
+        '("data", AttrOpt t)]
+
+_SoftmaxActivation ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "_SoftmaxActivation" t a,
+                      HasCallStack) =>
+                     ArgsHMap "_SoftmaxActivation" t a -> TensorApply t
+_SoftmaxActivation args
+  = let scalarArgs
+          = catMaybes
+              [("mode",) . showValue <$>
+                 (args !? #mode :: Maybe (EnumType '["channel", "instance"]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "SoftmaxActivation" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_SoftmaxOutput" t =
+     '[ '("grad_scale", AttrOpt Float),
+        '("ignore_label", AttrOpt Float), '("multi_output", AttrOpt Bool),
+        '("use_ignore", AttrOpt Bool), '("preserve_shape", AttrOpt Bool),
+        '("normalization", AttrOpt (EnumType '["batch", "null", "valid"])),
+        '("out_grad", AttrOpt Bool), '("smooth_alpha", AttrOpt Float),
+        '("data", AttrOpt t), '("label", AttrOpt t)]
+
+_SoftmaxOutput ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "_SoftmaxOutput" t a, HasCallStack) =>
+                 ArgsHMap "_SoftmaxOutput" t a -> TensorApply t
+_SoftmaxOutput args
+  = let scalarArgs
+          = catMaybes
+              [("grad_scale",) . showValue <$>
+                 (args !? #grad_scale :: Maybe Float),
+               ("ignore_label",) . showValue <$>
+                 (args !? #ignore_label :: Maybe Float),
+               ("multi_output",) . showValue <$>
+                 (args !? #multi_output :: Maybe Bool),
+               ("use_ignore",) . showValue <$>
+                 (args !? #use_ignore :: Maybe Bool),
+               ("preserve_shape",) . showValue <$>
+                 (args !? #preserve_shape :: Maybe Bool),
+               ("normalization",) . showValue <$>
+                 (args !? #normalization ::
+                    Maybe (EnumType '["batch", "null", "valid"])),
+               ("out_grad",) . showValue <$> (args !? #out_grad :: Maybe Bool),
+               ("smooth_alpha",) . showValue <$>
+                 (args !? #smooth_alpha :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("label",) <$> (args !? #label :: Maybe t)]
+      in
+      apply "SoftmaxOutput" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_SpatialTransformer" t =
+     '[ '("target_shape", AttrOpt [Int]),
+        '("transform_type", AttrReq (EnumType '["affine"])),
+        '("sampler_type", AttrReq (EnumType '["bilinear"])),
+        '("cudnn_off", AttrOpt (Maybe Bool)), '("data", AttrOpt t),
+        '("loc", AttrOpt t)]
+
+_SpatialTransformer ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "_SpatialTransformer" t a,
+                       HasCallStack) =>
+                      ArgsHMap "_SpatialTransformer" t a -> TensorApply t
+_SpatialTransformer args
+  = let scalarArgs
+          = catMaybes
+              [("target_shape",) . showValue <$>
+                 (args !? #target_shape :: Maybe [Int]),
+               ("transform_type",) . showValue <$>
+                 (args !? #transform_type :: Maybe (EnumType '["affine"])),
+               ("sampler_type",) . showValue <$>
+                 (args !? #sampler_type :: Maybe (EnumType '["bilinear"])),
+               ("cudnn_off",) . showValue <$>
+                 (args !? #cudnn_off :: Maybe (Maybe Bool))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("loc",) <$> (args !? #loc :: Maybe t)]
+      in
+      apply "SpatialTransformer" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_SwapAxis" t =
+     '[ '("dim1", AttrOpt Int), '("dim2", AttrOpt Int),
+        '("data", AttrOpt t)]
+
+_SwapAxis ::
+          forall a t .
+            (TensorOp t t, Fullfilled "_SwapAxis" t a, HasCallStack) =>
+            ArgsHMap "_SwapAxis" t a -> TensorApply t
+_SwapAxis args
+  = let scalarArgs
+          = catMaybes
+              [("dim1",) . showValue <$> (args !? #dim1 :: Maybe Int),
+               ("dim2",) . showValue <$> (args !? #dim2 :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "SwapAxis" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_UpSampling" t =
+     '[ '("scale", AttrReq Int), '("num_filter", AttrOpt Int),
+        '("sample_type", AttrReq (EnumType '["bilinear", "nearest"])),
+        '("multi_input_mode", AttrOpt (EnumType '["concat", "sum"])),
+        '("num_args", AttrReq Int), '("workspace", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+_UpSampling ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_UpSampling" t a, HasCallStack) =>
+              ArgsHMap "_UpSampling" t a -> TensorApply t
+_UpSampling args
+  = let scalarArgs
+          = catMaybes
+              [("scale",) . showValue <$> (args !? #scale :: Maybe Int),
+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
+               ("sample_type",) . showValue <$>
+                 (args !? #sample_type ::
+                    Maybe (EnumType '["bilinear", "nearest"])),
+               ("multi_input_mode",) . showValue <$>
+                 (args !? #multi_input_mode :: Maybe (EnumType '["concat", "sum"])),
+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "UpSampling" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__CachedOp" t =
+     '[ '("data", AttrOpt [t])]
+
+__CachedOp ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__CachedOp" t a, HasCallStack) =>
+             ArgsHMap "__CachedOp" t a -> TensorApply t
+__CachedOp args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "_CachedOp" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__CrossDeviceCopy" t = '[]
+
+__CrossDeviceCopy ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__CrossDeviceCopy" t a, HasCallStack) =>
+                    ArgsHMap "__CrossDeviceCopy" t a -> TensorApply t
+__CrossDeviceCopy args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_CrossDeviceCopy" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__CustomFunction" t = '[]
+
+__CustomFunction ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__CustomFunction" t a, HasCallStack) =>
+                   ArgsHMap "__CustomFunction" t a -> TensorApply t
+__CustomFunction args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_CustomFunction" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__FusedOp" t =
+     '[ '("data", AttrOpt [t])]
+
+__FusedOp ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__FusedOp" t a, HasCallStack) =>
+            ArgsHMap "__FusedOp" t a -> TensorApply t
+__FusedOp args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "_FusedOp" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__FusedOpHelper" t = '[]
+
+__FusedOpHelper ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__FusedOpHelper" t a, HasCallStack) =>
+                  ArgsHMap "__FusedOpHelper" t a -> TensorApply t
+__FusedOpHelper args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_FusedOpHelper" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__FusedOpOutHelper" t = '[]
+
+__FusedOpOutHelper ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__FusedOpOutHelper" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__FusedOpOutHelper" t a -> TensorApply t
+__FusedOpOutHelper args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_FusedOpOutHelper" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__NoGradient" t = '[]
+
+__NoGradient ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__NoGradient" t a, HasCallStack) =>
+               ArgsHMap "__NoGradient" t a -> TensorApply t
+__NoGradient args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_NoGradient" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__adamw_update" t =
+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
+        '("wd", AttrOpt Float), '("eta", AttrReq Float),
+        '("clip_gradient", AttrOpt Float), '("weight", AttrOpt t),
+        '("grad", AttrOpt t), '("mean", AttrOpt t), '("var", AttrOpt t),
+        '("rescale_grad", AttrOpt t)]
+
+__adamw_update ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__adamw_update" t a, HasCallStack) =>
+                 ArgsHMap "__adamw_update" t a -> TensorApply t
+__adamw_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("eta",) . showValue <$> (args !? #eta :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("mean",) <$> (args !? #mean :: Maybe t),
+               ("var",) <$> (args !? #var :: Maybe t),
+               ("rescale_grad",) <$> (args !? #rescale_grad :: Maybe t)]
+      in
+      apply "_adamw_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__arange" t =
+     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),
+        '("step", AttrOpt Double), '("repeat", AttrOpt Int),
+        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "int8",
+                 "uint8"]))]
+
+__arange ::
+         forall a t .
+           (TensorOp t t, Fullfilled "__arange" t a, HasCallStack) =>
+           ArgsHMap "__arange" t a -> TensorApply t
+__arange args
+  = let scalarArgs
+          = catMaybes
+              [("start",) . showValue <$> (args !? #start :: Maybe Double),
+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
+               ("step",) . showValue <$> (args !? #step :: Maybe Double),
+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
+               ("infer_range",) . showValue <$>
+                 (args !? #infer_range :: Maybe Bool),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "int8",
+                           "uint8"]))]
+        tensorKeyArgs = catMaybes []
+      in apply "_arange" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_Activation" t = '[]
+
+__backward_Activation ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_Activation" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_Activation" t a -> TensorApply t
+__backward_Activation args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_Activation" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_BatchNorm" t = '[]
+
+__backward_BatchNorm ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_BatchNorm" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_BatchNorm" t a -> TensorApply t
+__backward_BatchNorm args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_BatchNorm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_BatchNorm_v1" t = '[]
+
+__backward_BatchNorm_v1 ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward_BatchNorm_v1" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward_BatchNorm_v1" t a -> TensorApply t
+__backward_BatchNorm_v1 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_BatchNorm_v1" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_BilinearSampler" t = '[]
+
+__backward_BilinearSampler ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__backward_BilinearSampler" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__backward_BilinearSampler" t a -> TensorApply t
+__backward_BilinearSampler args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_BilinearSampler" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_CachedOp" t = '[]
+
+__backward_CachedOp ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__backward_CachedOp" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__backward_CachedOp" t a -> TensorApply t
+__backward_CachedOp args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_CachedOp" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_Concat" t = '[]
+
+__backward_Concat ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__backward_Concat" t a, HasCallStack) =>
+                    ArgsHMap "__backward_Concat" t a -> TensorApply t
+__backward_Concat args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_Concat" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_Convolution" t = '[]
+
+__backward_Convolution ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__backward_Convolution" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__backward_Convolution" t a -> TensorApply t
+__backward_Convolution args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_Convolution" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_Convolution_v1" t = '[]
+
+__backward_Convolution_v1 ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "__backward_Convolution_v1" t a,
+                             HasCallStack) =>
+                            ArgsHMap "__backward_Convolution_v1" t a -> TensorApply t
+__backward_Convolution_v1 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_Convolution_v1" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_Correlation" t = '[]
+
+__backward_Correlation ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__backward_Correlation" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__backward_Correlation" t a -> TensorApply t
+__backward_Correlation args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_Correlation" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_Crop" t = '[]
+
+__backward_Crop ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_Crop" t a, HasCallStack) =>
+                  ArgsHMap "__backward_Crop" t a -> TensorApply t
+__backward_Crop args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_Crop" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_CuDNNBatchNorm" t = '[]
+
+__backward_CuDNNBatchNorm ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "__backward_CuDNNBatchNorm" t a,
+                             HasCallStack) =>
+                            ArgsHMap "__backward_CuDNNBatchNorm" t a -> TensorApply t
+__backward_CuDNNBatchNorm args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_CuDNNBatchNorm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_Custom" t = '[]
+
+__backward_Custom ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__backward_Custom" t a, HasCallStack) =>
+                    ArgsHMap "__backward_Custom" t a -> TensorApply t
+__backward_Custom args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_Custom" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_CustomFunction" t = '[]
+
+__backward_CustomFunction ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "__backward_CustomFunction" t a,
+                             HasCallStack) =>
+                            ArgsHMap "__backward_CustomFunction" t a -> TensorApply t
+__backward_CustomFunction args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_CustomFunction" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_Deconvolution" t = '[]
+
+__backward_Deconvolution ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__backward_Deconvolution" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__backward_Deconvolution" t a -> TensorApply t
+__backward_Deconvolution args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_Deconvolution" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_Dropout" t = '[]
+
+__backward_Dropout ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_Dropout" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_Dropout" t a -> TensorApply t
+__backward_Dropout args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_Dropout" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_Embedding" t = '[]
+
+__backward_Embedding ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_Embedding" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_Embedding" t a -> TensorApply t
+__backward_Embedding args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_Embedding" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_FullyConnected" t = '[]
+
+__backward_FullyConnected ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "__backward_FullyConnected" t a,
+                             HasCallStack) =>
+                            ArgsHMap "__backward_FullyConnected" t a -> TensorApply t
+__backward_FullyConnected args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_FullyConnected" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_GridGenerator" t = '[]
+
+__backward_GridGenerator ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__backward_GridGenerator" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__backward_GridGenerator" t a -> TensorApply t
+__backward_GridGenerator args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_GridGenerator" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_GroupNorm" t = '[]
+
+__backward_GroupNorm ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_GroupNorm" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_GroupNorm" t a -> TensorApply t
+__backward_GroupNorm args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_GroupNorm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__backward_IdentityAttachKLSparseReg" t = '[]
+
+__backward_IdentityAttachKLSparseReg ::
+                                     forall a t .
+                                       (TensorOp t t,
+                                        Fullfilled "__backward_IdentityAttachKLSparseReg" t a,
+                                        HasCallStack) =>
+                                       ArgsHMap "__backward_IdentityAttachKLSparseReg" t a ->
+                                         TensorApply t
+__backward_IdentityAttachKLSparseReg args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_IdentityAttachKLSparseReg" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_InstanceNorm" t = '[]
+
+__backward_InstanceNorm ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward_InstanceNorm" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward_InstanceNorm" t a -> TensorApply t
+__backward_InstanceNorm args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_InstanceNorm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_L2Normalization" t = '[]
+
+__backward_L2Normalization ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__backward_L2Normalization" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__backward_L2Normalization" t a -> TensorApply t
+__backward_L2Normalization args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_L2Normalization" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_LRN" t = '[]
+
+__backward_LRN ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_LRN" t a, HasCallStack) =>
+                 ArgsHMap "__backward_LRN" t a -> TensorApply t
+__backward_LRN args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_LRN" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_LayerNorm" t = '[]
+
+__backward_LayerNorm ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_LayerNorm" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_LayerNorm" t a -> TensorApply t
+__backward_LayerNorm args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_LayerNorm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_LeakyReLU" t = '[]
+
+__backward_LeakyReLU ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_LeakyReLU" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_LeakyReLU" t a -> TensorApply t
+__backward_LeakyReLU args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_LeakyReLU" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_MakeLoss" t = '[]
+
+__backward_MakeLoss ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__backward_MakeLoss" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__backward_MakeLoss" t a -> TensorApply t
+__backward_MakeLoss args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_MakeLoss" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_Pad" t = '[]
+
+__backward_Pad ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_Pad" t a, HasCallStack) =>
+                 ArgsHMap "__backward_Pad" t a -> TensorApply t
+__backward_Pad args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_Pad" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_Pooling" t = '[]
+
+__backward_Pooling ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_Pooling" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_Pooling" t a -> TensorApply t
+__backward_Pooling args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_Pooling" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_Pooling_v1" t = '[]
+
+__backward_Pooling_v1 ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_Pooling_v1" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_Pooling_v1" t a -> TensorApply t
+__backward_Pooling_v1 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_Pooling_v1" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_RNN" t = '[]
+
+__backward_RNN ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_RNN" t a, HasCallStack) =>
+                 ArgsHMap "__backward_RNN" t a -> TensorApply t
+__backward_RNN args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_RNN" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_ROIAlign" t = '[]
+
+__backward_ROIAlign ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__backward_ROIAlign" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__backward_ROIAlign" t a -> TensorApply t
+__backward_ROIAlign args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_ROIAlign" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_ROIPooling" t = '[]
+
+__backward_ROIPooling ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_ROIPooling" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_ROIPooling" t a -> TensorApply t
+__backward_ROIPooling args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_ROIPooling" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_RROIAlign" t = '[]
+
+__backward_RROIAlign ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_RROIAlign" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_RROIAlign" t a -> TensorApply t
+__backward_RROIAlign args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_RROIAlign" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_SVMOutput" t = '[]
+
+__backward_SVMOutput ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_SVMOutput" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_SVMOutput" t a -> TensorApply t
+__backward_SVMOutput args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_SVMOutput" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_SequenceLast" t = '[]
+
+__backward_SequenceLast ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward_SequenceLast" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward_SequenceLast" t a -> TensorApply t
+__backward_SequenceLast args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_SequenceLast" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_SequenceMask" t = '[]
+
+__backward_SequenceMask ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward_SequenceMask" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward_SequenceMask" t a -> TensorApply t
+__backward_SequenceMask args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_SequenceMask" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_SequenceReverse" t = '[]
+
+__backward_SequenceReverse ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__backward_SequenceReverse" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__backward_SequenceReverse" t a -> TensorApply t
+__backward_SequenceReverse args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_SequenceReverse" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_SliceChannel" t = '[]
+
+__backward_SliceChannel ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward_SliceChannel" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward_SliceChannel" t a -> TensorApply t
+__backward_SliceChannel args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_SliceChannel" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_SoftmaxActivation" t = '[]
+
+__backward_SoftmaxActivation ::
+                             forall a t .
+                               (TensorOp t t, Fullfilled "__backward_SoftmaxActivation" t a,
+                                HasCallStack) =>
+                               ArgsHMap "__backward_SoftmaxActivation" t a -> TensorApply t
+__backward_SoftmaxActivation args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_SoftmaxActivation" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_SoftmaxOutput" t = '[]
+
+__backward_SoftmaxOutput ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__backward_SoftmaxOutput" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__backward_SoftmaxOutput" t a -> TensorApply t
+__backward_SoftmaxOutput args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_SoftmaxOutput" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_SparseEmbedding" t = '[]
+
+__backward_SparseEmbedding ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__backward_SparseEmbedding" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__backward_SparseEmbedding" t a -> TensorApply t
+__backward_SparseEmbedding args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_SparseEmbedding" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_SpatialTransformer" t = '[]
+
+__backward_SpatialTransformer ::
+                              forall a t .
+                                (TensorOp t t, Fullfilled "__backward_SpatialTransformer" t a,
+                                 HasCallStack) =>
+                                ArgsHMap "__backward_SpatialTransformer" t a -> TensorApply t
+__backward_SpatialTransformer args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_SpatialTransformer" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_SwapAxis" t = '[]
+
+__backward_SwapAxis ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__backward_SwapAxis" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__backward_SwapAxis" t a -> TensorApply t
+__backward_SwapAxis args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_SwapAxis" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_UpSampling" t = '[]
+
+__backward_UpSampling ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_UpSampling" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_UpSampling" t a -> TensorApply t
+__backward_UpSampling args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_UpSampling" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward__CrossDeviceCopy" t = '[]
+
+__backward__CrossDeviceCopy ::
+                            forall a t .
+                              (TensorOp t t, Fullfilled "__backward__CrossDeviceCopy" t a,
+                               HasCallStack) =>
+                              ArgsHMap "__backward__CrossDeviceCopy" t a -> TensorApply t
+__backward__CrossDeviceCopy args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__CrossDeviceCopy" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward__NDArray" t = '[]
+
+__backward__NDArray ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__backward__NDArray" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__backward__NDArray" t a -> TensorApply t
+__backward__NDArray args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__NDArray" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward__Native" t = '[]
+
+__backward__Native ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward__Native" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward__Native" t a -> TensorApply t
+__backward__Native args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__Native" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__backward__contrib_DeformableConvolution" t = '[]
+
+__backward__contrib_DeformableConvolution ::
+                                          forall a t .
+                                            (TensorOp t t,
+                                             Fullfilled "__backward__contrib_DeformableConvolution"
+                                               t a,
+                                             HasCallStack) =>
+                                            ArgsHMap "__backward__contrib_DeformableConvolution" t a
+                                              -> TensorApply t
+__backward__contrib_DeformableConvolution args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__contrib_DeformableConvolution" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__backward__contrib_DeformablePSROIPooling" t = '[]
+
+__backward__contrib_DeformablePSROIPooling ::
+                                           forall a t .
+                                             (TensorOp t t,
+                                              Fullfilled
+                                                "__backward__contrib_DeformablePSROIPooling" t a,
+                                              HasCallStack) =>
+                                             ArgsHMap "__backward__contrib_DeformablePSROIPooling" t
+                                               a
+                                               -> TensorApply t
+__backward__contrib_DeformablePSROIPooling args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__contrib_DeformablePSROIPooling" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__backward__contrib_MultiBoxDetection" t = '[]
+
+__backward__contrib_MultiBoxDetection ::
+                                      forall a t .
+                                        (TensorOp t t,
+                                         Fullfilled "__backward__contrib_MultiBoxDetection" t a,
+                                         HasCallStack) =>
+                                        ArgsHMap "__backward__contrib_MultiBoxDetection" t a ->
+                                          TensorApply t
+__backward__contrib_MultiBoxDetection args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__contrib_MultiBoxDetection" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward__contrib_MultiBoxPrior" t =
+     '[]
+
+__backward__contrib_MultiBoxPrior ::
+                                  forall a t .
+                                    (TensorOp t t,
+                                     Fullfilled "__backward__contrib_MultiBoxPrior" t a,
+                                     HasCallStack) =>
+                                    ArgsHMap "__backward__contrib_MultiBoxPrior" t a ->
+                                      TensorApply t
+__backward__contrib_MultiBoxPrior args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__contrib_MultiBoxPrior" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward__contrib_MultiBoxTarget" t
+     = '[]
+
+__backward__contrib_MultiBoxTarget ::
+                                   forall a t .
+                                     (TensorOp t t,
+                                      Fullfilled "__backward__contrib_MultiBoxTarget" t a,
+                                      HasCallStack) =>
+                                     ArgsHMap "__backward__contrib_MultiBoxTarget" t a ->
+                                       TensorApply t
+__backward__contrib_MultiBoxTarget args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__contrib_MultiBoxTarget" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward__contrib_MultiProposal" t =
+     '[]
+
+__backward__contrib_MultiProposal ::
+                                  forall a t .
+                                    (TensorOp t t,
+                                     Fullfilled "__backward__contrib_MultiProposal" t a,
+                                     HasCallStack) =>
+                                    ArgsHMap "__backward__contrib_MultiProposal" t a ->
+                                      TensorApply t
+__backward__contrib_MultiProposal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__contrib_MultiProposal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward__contrib_PSROIPooling" t =
+     '[]
+
+__backward__contrib_PSROIPooling ::
+                                 forall a t .
+                                   (TensorOp t t, Fullfilled "__backward__contrib_PSROIPooling" t a,
+                                    HasCallStack) =>
+                                   ArgsHMap "__backward__contrib_PSROIPooling" t a -> TensorApply t
+__backward__contrib_PSROIPooling args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__contrib_PSROIPooling" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward__contrib_Proposal" t = '[]
+
+__backward__contrib_Proposal ::
+                             forall a t .
+                               (TensorOp t t, Fullfilled "__backward__contrib_Proposal" t a,
+                                HasCallStack) =>
+                               ArgsHMap "__backward__contrib_Proposal" t a -> TensorApply t
+__backward__contrib_Proposal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__contrib_Proposal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward__contrib_SyncBatchNorm" t =
+     '[]
+
+__backward__contrib_SyncBatchNorm ::
+                                  forall a t .
+                                    (TensorOp t t,
+                                     Fullfilled "__backward__contrib_SyncBatchNorm" t a,
+                                     HasCallStack) =>
+                                    ArgsHMap "__backward__contrib_SyncBatchNorm" t a ->
+                                      TensorApply t
+__backward__contrib_SyncBatchNorm args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__contrib_SyncBatchNorm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward__contrib_count_sketch" t =
+     '[]
+
+__backward__contrib_count_sketch ::
+                                 forall a t .
+                                   (TensorOp t t, Fullfilled "__backward__contrib_count_sketch" t a,
+                                    HasCallStack) =>
+                                   ArgsHMap "__backward__contrib_count_sketch" t a -> TensorApply t
+__backward__contrib_count_sketch args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__contrib_count_sketch" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward__contrib_fft" t = '[]
+
+__backward__contrib_fft ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward__contrib_fft" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward__contrib_fft" t a -> TensorApply t
+__backward__contrib_fft args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__contrib_fft" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward__contrib_ifft" t = '[]
+
+__backward__contrib_ifft ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__backward__contrib_ifft" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__backward__contrib_ifft" t a -> TensorApply t
+__backward__contrib_ifft args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward__contrib_ifft" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_abs" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_abs ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_abs" t a, HasCallStack) =>
+                 ArgsHMap "__backward_abs" t a -> TensorApply t
+__backward_abs args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_abs" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_add" t = '[]
+
+__backward_add ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_add" t a, HasCallStack) =>
+                 ArgsHMap "__backward_add" t a -> TensorApply t
+__backward_add args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_add" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_amp_cast" t = '[]
+
+__backward_amp_cast ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__backward_amp_cast" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__backward_amp_cast" t a -> TensorApply t
+__backward_amp_cast args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_amp_cast" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_amp_multicast" t =
+     '[ '("num_outputs", AttrReq Int), '("cast_narrow", AttrOpt Bool),
+        '("grad", AttrOpt [t])]
+
+__backward_amp_multicast ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__backward_amp_multicast" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__backward_amp_multicast" t a -> TensorApply t
+__backward_amp_multicast args
+  = let scalarArgs
+          = catMaybes
+              [("num_outputs",) . showValue <$>
+                 (args !? #num_outputs :: Maybe Int),
+               ("cast_narrow",) . showValue <$>
+                 (args !? #cast_narrow :: Maybe Bool)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #grad :: Maybe [t])
+      in apply "_backward_amp_multicast" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__backward_arccos" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_arccos ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__backward_arccos" t a, HasCallStack) =>
+                    ArgsHMap "__backward_arccos" t a -> TensorApply t
+__backward_arccos args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_arccos" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_arccosh" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_arccosh ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_arccosh" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_arccosh" t a -> TensorApply t
+__backward_arccosh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_arccosh" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_arcsin" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_arcsin ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__backward_arcsin" t a, HasCallStack) =>
+                    ArgsHMap "__backward_arcsin" t a -> TensorApply t
+__backward_arcsin args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_arcsin" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_arcsinh" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_arcsinh ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_arcsinh" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_arcsinh" t a -> TensorApply t
+__backward_arcsinh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_arcsinh" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_arctan" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_arctan ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__backward_arctan" t a, HasCallStack) =>
+                    ArgsHMap "__backward_arctan" t a -> TensorApply t
+__backward_arctan args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_arctan" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_arctanh" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_arctanh ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_arctanh" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_arctanh" t a -> TensorApply t
+__backward_arctanh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_arctanh" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_backward_FullyConnected" t
+     = '[]
+
+__backward_backward_FullyConnected ::
+                                   forall a t .
+                                     (TensorOp t t,
+                                      Fullfilled "__backward_backward_FullyConnected" t a,
+                                      HasCallStack) =>
+                                     ArgsHMap "__backward_backward_FullyConnected" t a ->
+                                       TensorApply t
+__backward_backward_FullyConnected args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_backward_FullyConnected" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_broadcast_add" t = '[]
+
+__backward_broadcast_add ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__backward_broadcast_add" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__backward_broadcast_add" t a -> TensorApply t
+__backward_broadcast_add args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_broadcast_add" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_broadcast_div" t = '[]
+
+__backward_broadcast_div ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__backward_broadcast_div" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__backward_broadcast_div" t a -> TensorApply t
+__backward_broadcast_div args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_broadcast_div" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_broadcast_hypot" t = '[]
+
+__backward_broadcast_hypot ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__backward_broadcast_hypot" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__backward_broadcast_hypot" t a -> TensorApply t
+__backward_broadcast_hypot args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_broadcast_hypot" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_broadcast_maximum" t = '[]
+
+__backward_broadcast_maximum ::
+                             forall a t .
+                               (TensorOp t t, Fullfilled "__backward_broadcast_maximum" t a,
+                                HasCallStack) =>
+                               ArgsHMap "__backward_broadcast_maximum" t a -> TensorApply t
+__backward_broadcast_maximum args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_broadcast_maximum" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_broadcast_minimum" t = '[]
+
+__backward_broadcast_minimum ::
+                             forall a t .
+                               (TensorOp t t, Fullfilled "__backward_broadcast_minimum" t a,
+                                HasCallStack) =>
+                               ArgsHMap "__backward_broadcast_minimum" t a -> TensorApply t
+__backward_broadcast_minimum args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_broadcast_minimum" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_broadcast_mod" t = '[]
+
+__backward_broadcast_mod ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__backward_broadcast_mod" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__backward_broadcast_mod" t a -> TensorApply t
+__backward_broadcast_mod args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_broadcast_mod" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_broadcast_mul" t = '[]
+
+__backward_broadcast_mul ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__backward_broadcast_mul" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__backward_broadcast_mul" t a -> TensorApply t
+__backward_broadcast_mul args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_broadcast_mul" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_broadcast_power" t = '[]
+
+__backward_broadcast_power ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__backward_broadcast_power" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__backward_broadcast_power" t a -> TensorApply t
+__backward_broadcast_power args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_broadcast_power" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_broadcast_sub" t = '[]
+
+__backward_broadcast_sub ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__backward_broadcast_sub" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__backward_broadcast_sub" t a -> TensorApply t
+__backward_broadcast_sub args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_broadcast_sub" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_cast" t = '[]
+
+__backward_cast ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_cast" t a, HasCallStack) =>
+                  ArgsHMap "__backward_cast" t a -> TensorApply t
+__backward_cast args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_cast" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_cbrt" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_cbrt ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_cbrt" t a, HasCallStack) =>
+                  ArgsHMap "__backward_cbrt" t a -> TensorApply t
+__backward_cbrt args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_cbrt" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_clip" t = '[]
+
+__backward_clip ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_clip" t a, HasCallStack) =>
+                  ArgsHMap "__backward_clip" t a -> TensorApply t
+__backward_clip args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_clip" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_cond" t = '[]
+
+__backward_cond ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_cond" t a, HasCallStack) =>
+                  ArgsHMap "__backward_cond" t a -> TensorApply t
+__backward_cond args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_cond" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__backward_contrib_AdaptiveAvgPooling2D" t = '[]
+
+__backward_contrib_AdaptiveAvgPooling2D ::
+                                        forall a t .
+                                          (TensorOp t t,
+                                           Fullfilled "__backward_contrib_AdaptiveAvgPooling2D" t a,
+                                           HasCallStack) =>
+                                          ArgsHMap "__backward_contrib_AdaptiveAvgPooling2D" t a ->
+                                            TensorApply t
+__backward_contrib_AdaptiveAvgPooling2D args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_contrib_AdaptiveAvgPooling2D" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_contrib_BilinearResize2D" t
+     = '[]
+
+__backward_contrib_BilinearResize2D ::
+                                    forall a t .
+                                      (TensorOp t t,
+                                       Fullfilled "__backward_contrib_BilinearResize2D" t a,
+                                       HasCallStack) =>
+                                      ArgsHMap "__backward_contrib_BilinearResize2D" t a ->
+                                        TensorApply t
+__backward_contrib_BilinearResize2D args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_contrib_BilinearResize2D" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__backward_contrib_bipartite_matching" t =
+     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),
+        '("topk", AttrOpt Int)]
+
+__backward_contrib_bipartite_matching ::
+                                      forall a t .
+                                        (TensorOp t t,
+                                         Fullfilled "__backward_contrib_bipartite_matching" t a,
+                                         HasCallStack) =>
+                                        ArgsHMap "__backward_contrib_bipartite_matching" t a ->
+                                          TensorApply t
+__backward_contrib_bipartite_matching args
+  = let scalarArgs
+          = catMaybes
+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_contrib_bipartite_matching" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_contrib_boolean_mask" t =
+     '[ '("axis", AttrOpt Int)]
+
+__backward_contrib_boolean_mask ::
+                                forall a t .
+                                  (TensorOp t t, Fullfilled "__backward_contrib_boolean_mask" t a,
+                                   HasCallStack) =>
+                                  ArgsHMap "__backward_contrib_boolean_mask" t a -> TensorApply t
+__backward_contrib_boolean_mask args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_contrib_boolean_mask" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_contrib_box_iou" t =
+     '[ '("format", AttrOpt (EnumType '["center", "corner"]))]
+
+__backward_contrib_box_iou ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__backward_contrib_box_iou" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__backward_contrib_box_iou" t a -> TensorApply t
+__backward_contrib_box_iou args
+  = let scalarArgs
+          = catMaybes
+              [("format",) . showValue <$>
+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_contrib_box_iou" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_contrib_box_nms" t =
+     '[ '("overlap_thresh", AttrOpt Float),
+        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),
+        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),
+        '("id_index", AttrOpt Int), '("background_id", AttrOpt Int),
+        '("force_suppress", AttrOpt Bool),
+        '("in_format", AttrOpt (EnumType '["center", "corner"])),
+        '("out_format", AttrOpt (EnumType '["center", "corner"]))]
+
+__backward_contrib_box_nms ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__backward_contrib_box_nms" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__backward_contrib_box_nms" t a -> TensorApply t
+__backward_contrib_box_nms args
+  = let scalarArgs
+          = catMaybes
+              [("overlap_thresh",) . showValue <$>
+                 (args !? #overlap_thresh :: Maybe Float),
+               ("valid_thresh",) . showValue <$>
+                 (args !? #valid_thresh :: Maybe Float),
+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
+               ("coord_start",) . showValue <$>
+                 (args !? #coord_start :: Maybe Int),
+               ("score_index",) . showValue <$>
+                 (args !? #score_index :: Maybe Int),
+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
+               ("background_id",) . showValue <$>
+                 (args !? #background_id :: Maybe Int),
+               ("force_suppress",) . showValue <$>
+                 (args !? #force_suppress :: Maybe Bool),
+               ("in_format",) . showValue <$>
+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
+               ("out_format",) . showValue <$>
+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_contrib_box_nms" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_copy" t = '[]
+
+__backward_copy ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_copy" t a, HasCallStack) =>
+                  ArgsHMap "__backward_copy" t a -> TensorApply t
+__backward_copy args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_copy" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_cos" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_cos ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_cos" t a, HasCallStack) =>
+                 ArgsHMap "__backward_cos" t a -> TensorApply t
+__backward_cos args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_cos" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_cosh" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_cosh ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_cosh" t a, HasCallStack) =>
+                  ArgsHMap "__backward_cosh" t a -> TensorApply t
+__backward_cosh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_cosh" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_ctc_loss" t = '[]
+
+__backward_ctc_loss ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__backward_ctc_loss" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__backward_ctc_loss" t a -> TensorApply t
+__backward_ctc_loss args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_ctc_loss" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_degrees" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_degrees ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_degrees" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_degrees" t a -> TensorApply t
+__backward_degrees args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_degrees" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_diag" t = '[]
+
+__backward_diag ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_diag" t a, HasCallStack) =>
+                  ArgsHMap "__backward_diag" t a -> TensorApply t
+__backward_diag args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_diag" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_div" t = '[]
+
+__backward_div ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_div" t a, HasCallStack) =>
+                 ArgsHMap "__backward_div" t a -> TensorApply t
+__backward_div args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_div" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_div_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__backward_div_scalar ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_div_scalar" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_div_scalar" t a -> TensorApply t
+__backward_div_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_backward_div_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_dot" t =
+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
+        '("forward_stype",
+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"])))]
+
+__backward_dot ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_dot" t a, HasCallStack) =>
+                 ArgsHMap "__backward_dot" t a -> TensorApply t
+__backward_dot args
+  = let scalarArgs
+          = catMaybes
+              [("transpose_a",) . showValue <$>
+                 (args !? #transpose_a :: Maybe Bool),
+               ("transpose_b",) . showValue <$>
+                 (args !? #transpose_b :: Maybe Bool),
+               ("forward_stype",) . showValue <$>
+                 (args !? #forward_stype ::
+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_dot" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_erf" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_erf ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_erf" t a, HasCallStack) =>
+                 ArgsHMap "__backward_erf" t a -> TensorApply t
+__backward_erf args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_erf" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_erfinv" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_erfinv ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__backward_erfinv" t a, HasCallStack) =>
+                    ArgsHMap "__backward_erfinv" t a -> TensorApply t
+__backward_erfinv args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_erfinv" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_expm1" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_expm1 ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__backward_expm1" t a, HasCallStack) =>
+                   ArgsHMap "__backward_expm1" t a -> TensorApply t
+__backward_expm1 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_expm1" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_foreach" t = '[]
+
+__backward_foreach ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_foreach" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_foreach" t a -> TensorApply t
+__backward_foreach args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_foreach" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_gamma" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_gamma ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__backward_gamma" t a, HasCallStack) =>
+                   ArgsHMap "__backward_gamma" t a -> TensorApply t
+__backward_gamma args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_gamma" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_gammaln" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_gammaln ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_gammaln" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_gammaln" t a -> TensorApply t
+__backward_gammaln args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_gammaln" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_gather_nd" t =
+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt t),
+        '("indices", AttrOpt t)]
+
+__backward_gather_nd ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_gather_nd" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_gather_nd" t a -> TensorApply t
+__backward_gather_nd args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("indices",) <$> (args !? #indices :: Maybe t)]
+      in
+      apply "_backward_gather_nd" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_hard_sigmoid" t = '[]
+
+__backward_hard_sigmoid ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward_hard_sigmoid" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward_hard_sigmoid" t a -> TensorApply t
+__backward_hard_sigmoid args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_hard_sigmoid" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_hypot" t = '[]
+
+__backward_hypot ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__backward_hypot" t a, HasCallStack) =>
+                   ArgsHMap "__backward_hypot" t a -> TensorApply t
+__backward_hypot args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_hypot" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_hypot_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t)]
+
+__backward_hypot_scalar ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward_hypot_scalar" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward_hypot_scalar" t a -> TensorApply t
+__backward_hypot_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_hypot_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_image_crop" t = '[]
+
+__backward_image_crop ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_image_crop" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_image_crop" t a -> TensorApply t
+__backward_image_crop args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_image_crop" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_image_normalize" t = '[]
+
+__backward_image_normalize ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__backward_image_normalize" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__backward_image_normalize" t a -> TensorApply t
+__backward_image_normalize args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_image_normalize" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__backward_interleaved_matmul_encdec_qk" t = '[]
+
+__backward_interleaved_matmul_encdec_qk ::
+                                        forall a t .
+                                          (TensorOp t t,
+                                           Fullfilled "__backward_interleaved_matmul_encdec_qk" t a,
+                                           HasCallStack) =>
+                                          ArgsHMap "__backward_interleaved_matmul_encdec_qk" t a ->
+                                            TensorApply t
+__backward_interleaved_matmul_encdec_qk args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_interleaved_matmul_encdec_qk" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__backward_interleaved_matmul_encdec_valatt" t = '[]
+
+__backward_interleaved_matmul_encdec_valatt ::
+                                            forall a t .
+                                              (TensorOp t t,
+                                               Fullfilled
+                                                 "__backward_interleaved_matmul_encdec_valatt" t a,
+                                               HasCallStack) =>
+                                              ArgsHMap "__backward_interleaved_matmul_encdec_valatt"
+                                                t
+                                                a
+                                                -> TensorApply t
+__backward_interleaved_matmul_encdec_valatt args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_interleaved_matmul_encdec_valatt" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__backward_interleaved_matmul_selfatt_qk" t = '[]
+
+__backward_interleaved_matmul_selfatt_qk ::
+                                         forall a t .
+                                           (TensorOp t t,
+                                            Fullfilled "__backward_interleaved_matmul_selfatt_qk" t
+                                              a,
+                                            HasCallStack) =>
+                                           ArgsHMap "__backward_interleaved_matmul_selfatt_qk" t a
+                                             -> TensorApply t
+__backward_interleaved_matmul_selfatt_qk args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_interleaved_matmul_selfatt_qk" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__backward_interleaved_matmul_selfatt_valatt" t =
+     '[]
+
+__backward_interleaved_matmul_selfatt_valatt ::
+                                             forall a t .
+                                               (TensorOp t t,
+                                                Fullfilled
+                                                  "__backward_interleaved_matmul_selfatt_valatt" t
+                                                  a,
+                                                HasCallStack) =>
+                                               ArgsHMap
+                                                 "__backward_interleaved_matmul_selfatt_valatt"
+                                                 t
+                                                 a
+                                                 -> TensorApply t
+__backward_interleaved_matmul_selfatt_valatt args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_interleaved_matmul_selfatt_valatt" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_det" t = '[]
+
+__backward_linalg_det ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_linalg_det" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_linalg_det" t a -> TensorApply t
+__backward_linalg_det args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_det" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_extractdiag" t = '[]
+
+__backward_linalg_extractdiag ::
+                              forall a t .
+                                (TensorOp t t, Fullfilled "__backward_linalg_extractdiag" t a,
+                                 HasCallStack) =>
+                                ArgsHMap "__backward_linalg_extractdiag" t a -> TensorApply t
+__backward_linalg_extractdiag args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_extractdiag" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_extracttrian" t =
+     '[]
+
+__backward_linalg_extracttrian ::
+                               forall a t .
+                                 (TensorOp t t, Fullfilled "__backward_linalg_extracttrian" t a,
+                                  HasCallStack) =>
+                                 ArgsHMap "__backward_linalg_extracttrian" t a -> TensorApply t
+__backward_linalg_extracttrian args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_extracttrian" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_gelqf" t = '[]
+
+__backward_linalg_gelqf ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward_linalg_gelqf" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward_linalg_gelqf" t a -> TensorApply t
+__backward_linalg_gelqf args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_gelqf" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_gemm" t = '[]
+
+__backward_linalg_gemm ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__backward_linalg_gemm" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__backward_linalg_gemm" t a -> TensorApply t
+__backward_linalg_gemm args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_gemm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_gemm2" t = '[]
+
+__backward_linalg_gemm2 ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward_linalg_gemm2" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward_linalg_gemm2" t a -> TensorApply t
+__backward_linalg_gemm2 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_gemm2" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_inverse" t = '[]
+
+__backward_linalg_inverse ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "__backward_linalg_inverse" t a,
+                             HasCallStack) =>
+                            ArgsHMap "__backward_linalg_inverse" t a -> TensorApply t
+__backward_linalg_inverse args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_inverse" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_makediag" t = '[]
+
+__backward_linalg_makediag ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__backward_linalg_makediag" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__backward_linalg_makediag" t a -> TensorApply t
+__backward_linalg_makediag args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_makediag" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_maketrian" t = '[]
+
+__backward_linalg_maketrian ::
+                            forall a t .
+                              (TensorOp t t, Fullfilled "__backward_linalg_maketrian" t a,
+                               HasCallStack) =>
+                              ArgsHMap "__backward_linalg_maketrian" t a -> TensorApply t
+__backward_linalg_maketrian args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_maketrian" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_potrf" t = '[]
+
+__backward_linalg_potrf ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward_linalg_potrf" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward_linalg_potrf" t a -> TensorApply t
+__backward_linalg_potrf args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_potrf" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_potri" t = '[]
+
+__backward_linalg_potri ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward_linalg_potri" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward_linalg_potri" t a -> TensorApply t
+__backward_linalg_potri args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_potri" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_slogdet" t = '[]
+
+__backward_linalg_slogdet ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "__backward_linalg_slogdet" t a,
+                             HasCallStack) =>
+                            ArgsHMap "__backward_linalg_slogdet" t a -> TensorApply t
+__backward_linalg_slogdet args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_slogdet" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_sumlogdiag" t = '[]
+
+__backward_linalg_sumlogdiag ::
+                             forall a t .
+                               (TensorOp t t, Fullfilled "__backward_linalg_sumlogdiag" t a,
+                                HasCallStack) =>
+                               ArgsHMap "__backward_linalg_sumlogdiag" t a -> TensorApply t
+__backward_linalg_sumlogdiag args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_sumlogdiag" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_syevd" t = '[]
+
+__backward_linalg_syevd ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward_linalg_syevd" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward_linalg_syevd" t a -> TensorApply t
+__backward_linalg_syevd args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_syevd" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_syrk" t = '[]
+
+__backward_linalg_syrk ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__backward_linalg_syrk" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__backward_linalg_syrk" t a -> TensorApply t
+__backward_linalg_syrk args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_syrk" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_trmm" t = '[]
+
+__backward_linalg_trmm ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__backward_linalg_trmm" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__backward_linalg_trmm" t a -> TensorApply t
+__backward_linalg_trmm args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_trmm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linalg_trsm" t = '[]
+
+__backward_linalg_trsm ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__backward_linalg_trsm" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__backward_linalg_trsm" t a -> TensorApply t
+__backward_linalg_trsm args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linalg_trsm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_linear_reg_out" t = '[]
+
+__backward_linear_reg_out ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "__backward_linear_reg_out" t a,
+                             HasCallStack) =>
+                            ArgsHMap "__backward_linear_reg_out" t a -> TensorApply t
+__backward_linear_reg_out args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_linear_reg_out" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_log" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_log ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_log" t a, HasCallStack) =>
+                 ArgsHMap "__backward_log" t a -> TensorApply t
+__backward_log args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_log" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_log10" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_log10 ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__backward_log10" t a, HasCallStack) =>
+                   ArgsHMap "__backward_log10" t a -> TensorApply t
+__backward_log10 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_log10" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_log1p" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_log1p ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__backward_log1p" t a, HasCallStack) =>
+                   ArgsHMap "__backward_log1p" t a -> TensorApply t
+__backward_log1p args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_log1p" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_log2" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_log2 ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_log2" t a, HasCallStack) =>
+                  ArgsHMap "__backward_log2" t a -> TensorApply t
+__backward_log2 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_log2" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_log_softmax" t =
+     '[ '("args", AttrOpt [t])]
+
+__backward_log_softmax ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__backward_log_softmax" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__backward_log_softmax" t a -> TensorApply t
+__backward_log_softmax args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #args :: Maybe [t])
+      in apply "_backward_log_softmax" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__backward_logistic_reg_out" t = '[]
+
+__backward_logistic_reg_out ::
+                            forall a t .
+                              (TensorOp t t, Fullfilled "__backward_logistic_reg_out" t a,
+                               HasCallStack) =>
+                              ArgsHMap "__backward_logistic_reg_out" t a -> TensorApply t
+__backward_logistic_reg_out args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_logistic_reg_out" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_mae_reg_out" t = '[]
+
+__backward_mae_reg_out ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__backward_mae_reg_out" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__backward_mae_reg_out" t a -> TensorApply t
+__backward_mae_reg_out args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_mae_reg_out" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_max" t = '[]
+
+__backward_max ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_max" t a, HasCallStack) =>
+                 ArgsHMap "__backward_max" t a -> TensorApply t
+__backward_max args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_max" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_maximum" t = '[]
+
+__backward_maximum ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_maximum" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_maximum" t a -> TensorApply t
+__backward_maximum args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_maximum" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_maximum_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t)]
+
+__backward_maximum_scalar ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "__backward_maximum_scalar" t a,
+                             HasCallStack) =>
+                            ArgsHMap "__backward_maximum_scalar" t a -> TensorApply t
+__backward_maximum_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_maximum_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_mean" t = '[]
+
+__backward_mean ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_mean" t a, HasCallStack) =>
+                  ArgsHMap "__backward_mean" t a -> TensorApply t
+__backward_mean args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_mean" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_min" t = '[]
+
+__backward_min ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_min" t a, HasCallStack) =>
+                 ArgsHMap "__backward_min" t a -> TensorApply t
+__backward_min args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_min" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_minimum" t = '[]
+
+__backward_minimum ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_minimum" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_minimum" t a -> TensorApply t
+__backward_minimum args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_minimum" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_minimum_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t)]
+
+__backward_minimum_scalar ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "__backward_minimum_scalar" t a,
+                             HasCallStack) =>
+                            ArgsHMap "__backward_minimum_scalar" t a -> TensorApply t
+__backward_minimum_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_minimum_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_mod" t = '[]
+
+__backward_mod ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_mod" t a, HasCallStack) =>
+                 ArgsHMap "__backward_mod" t a -> TensorApply t
+__backward_mod args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_mod" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_mod_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t)]
+
+__backward_mod_scalar ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_mod_scalar" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_mod_scalar" t a -> TensorApply t
+__backward_mod_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_mod_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_moments" t = '[]
+
+__backward_moments ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_moments" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_moments" t a -> TensorApply t
+__backward_moments args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_moments" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_mul" t = '[]
+
+__backward_mul ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_mul" t a, HasCallStack) =>
+                 ArgsHMap "__backward_mul" t a -> TensorApply t
+__backward_mul args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_mul" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_mul_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__backward_mul_scalar ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_mul_scalar" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_mul_scalar" t a -> TensorApply t
+__backward_mul_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_backward_mul_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_nanprod" t = '[]
+
+__backward_nanprod ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_nanprod" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_nanprod" t a -> TensorApply t
+__backward_nanprod args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_nanprod" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_nansum" t = '[]
+
+__backward_nansum ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__backward_nansum" t a, HasCallStack) =>
+                    ArgsHMap "__backward_nansum" t a -> TensorApply t
+__backward_nansum args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_nansum" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_norm" t = '[]
+
+__backward_norm ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_norm" t a, HasCallStack) =>
+                  ArgsHMap "__backward_norm" t a -> TensorApply t
+__backward_norm args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_norm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_np_broadcast_to" t = '[]
+
+__backward_np_broadcast_to ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__backward_np_broadcast_to" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__backward_np_broadcast_to" t a -> TensorApply t
+__backward_np_broadcast_to args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_np_broadcast_to" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_np_column_stack" t = '[]
+
+__backward_np_column_stack ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__backward_np_column_stack" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__backward_np_column_stack" t a -> TensorApply t
+__backward_np_column_stack args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_np_column_stack" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_np_concat" t = '[]
+
+__backward_np_concat ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_np_concat" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_np_concat" t a -> TensorApply t
+__backward_np_concat args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_np_concat" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_np_cumsum" t = '[]
+
+__backward_np_cumsum ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_np_cumsum" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_np_cumsum" t a -> TensorApply t
+__backward_np_cumsum args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_np_cumsum" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_np_dot" t = '[]
+
+__backward_np_dot ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__backward_np_dot" t a, HasCallStack) =>
+                    ArgsHMap "__backward_np_dot" t a -> TensorApply t
+__backward_np_dot args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_np_dot" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_np_dstack" t = '[]
+
+__backward_np_dstack ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_np_dstack" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_np_dstack" t a -> TensorApply t
+__backward_np_dstack args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_np_dstack" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_np_max" t = '[]
+
+__backward_np_max ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__backward_np_max" t a, HasCallStack) =>
+                    ArgsHMap "__backward_np_max" t a -> TensorApply t
+__backward_np_max args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_np_max" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_np_mean" t = '[]
+
+__backward_np_mean ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_np_mean" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_np_mean" t a -> TensorApply t
+__backward_np_mean args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_np_mean" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_np_min" t = '[]
+
+__backward_np_min ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__backward_np_min" t a, HasCallStack) =>
+                    ArgsHMap "__backward_np_min" t a -> TensorApply t
+__backward_np_min args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_np_min" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_np_prod" t = '[]
+
+__backward_np_prod ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_np_prod" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_np_prod" t a -> TensorApply t
+__backward_np_prod args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_np_prod" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_np_sum" t = '[]
+
+__backward_np_sum ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__backward_np_sum" t a, HasCallStack) =>
+                    ArgsHMap "__backward_np_sum" t a -> TensorApply t
+__backward_np_sum args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_np_sum" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_np_trace" t = '[]
+
+__backward_np_trace ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__backward_np_trace" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__backward_np_trace" t a -> TensorApply t
+__backward_np_trace args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_np_trace" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_np_vstack" t = '[]
+
+__backward_np_vstack ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_np_vstack" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_np_vstack" t a -> TensorApply t
+__backward_np_vstack args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_np_vstack" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_arctan2" t = '[]
+
+__backward_npi_arctan2 ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__backward_npi_arctan2" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__backward_npi_arctan2" t a -> TensorApply t
+__backward_npi_arctan2 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_npi_arctan2" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_arctan2_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t)]
+
+__backward_npi_arctan2_scalar ::
+                              forall a t .
+                                (TensorOp t t, Fullfilled "__backward_npi_arctan2_scalar" t a,
+                                 HasCallStack) =>
+                                ArgsHMap "__backward_npi_arctan2_scalar" t a -> TensorApply t
+__backward_npi_arctan2_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_npi_arctan2_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_broadcast_mul" t = '[]
+
+__backward_npi_broadcast_mul ::
+                             forall a t .
+                               (TensorOp t t, Fullfilled "__backward_npi_broadcast_mul" t a,
+                                HasCallStack) =>
+                               ArgsHMap "__backward_npi_broadcast_mul" t a -> TensorApply t
+__backward_npi_broadcast_mul args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_npi_broadcast_mul" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_copysign" t = '[]
+
+__backward_npi_copysign ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward_npi_copysign" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward_npi_copysign" t a -> TensorApply t
+__backward_npi_copysign args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_npi_copysign" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_copysign_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__backward_npi_copysign_scalar ::
+                               forall a t .
+                                 (TensorOp t t, Fullfilled "__backward_npi_copysign_scalar" t a,
+                                  HasCallStack) =>
+                                 ArgsHMap "__backward_npi_copysign_scalar" t a -> TensorApply t
+__backward_npi_copysign_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_backward_npi_copysign_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_diff" t = '[]
+
+__backward_npi_diff ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__backward_npi_diff" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__backward_npi_diff" t a -> TensorApply t
+__backward_npi_diff args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_npi_diff" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_einsum" t = '[]
+
+__backward_npi_einsum ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_npi_einsum" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_npi_einsum" t a -> TensorApply t
+__backward_npi_einsum args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_npi_einsum" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_flip" t = '[]
+
+__backward_npi_flip ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__backward_npi_flip" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__backward_npi_flip" t a -> TensorApply t
+__backward_npi_flip args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_npi_flip" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_hypot" t = '[]
+
+__backward_npi_hypot ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_npi_hypot" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_npi_hypot" t a -> TensorApply t
+__backward_npi_hypot args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_npi_hypot" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_ldexp" t = '[]
+
+__backward_npi_ldexp ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_npi_ldexp" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_npi_ldexp" t a -> TensorApply t
+__backward_npi_ldexp args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_npi_ldexp" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_ldexp_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t)]
+
+__backward_npi_ldexp_scalar ::
+                            forall a t .
+                              (TensorOp t t, Fullfilled "__backward_npi_ldexp_scalar" t a,
+                               HasCallStack) =>
+                              ArgsHMap "__backward_npi_ldexp_scalar" t a -> TensorApply t
+__backward_npi_ldexp_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_npi_ldexp_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_rarctan2_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t)]
+
+__backward_npi_rarctan2_scalar ::
+                               forall a t .
+                                 (TensorOp t t, Fullfilled "__backward_npi_rarctan2_scalar" t a,
+                                  HasCallStack) =>
+                                 ArgsHMap "__backward_npi_rarctan2_scalar" t a -> TensorApply t
+__backward_npi_rarctan2_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_npi_rarctan2_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_rcopysign_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__backward_npi_rcopysign_scalar ::
+                                forall a t .
+                                  (TensorOp t t, Fullfilled "__backward_npi_rcopysign_scalar" t a,
+                                   HasCallStack) =>
+                                  ArgsHMap "__backward_npi_rcopysign_scalar" t a -> TensorApply t
+__backward_npi_rcopysign_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_backward_npi_rcopysign_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_rldexp_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t)]
+
+__backward_npi_rldexp_scalar ::
+                             forall a t .
+                               (TensorOp t t, Fullfilled "__backward_npi_rldexp_scalar" t a,
+                                HasCallStack) =>
+                               ArgsHMap "__backward_npi_rldexp_scalar" t a -> TensorApply t
+__backward_npi_rldexp_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_npi_rldexp_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_svd" t = '[]
+
+__backward_npi_svd ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_npi_svd" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_npi_svd" t a -> TensorApply t
+__backward_npi_svd args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_npi_svd" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_tensordot" t = '[]
+
+__backward_npi_tensordot ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__backward_npi_tensordot" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__backward_npi_tensordot" t a -> TensorApply t
+__backward_npi_tensordot args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_npi_tensordot" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_npi_tensordot_int_axes" t =
+     '[]
+
+__backward_npi_tensordot_int_axes ::
+                                  forall a t .
+                                    (TensorOp t t,
+                                     Fullfilled "__backward_npi_tensordot_int_axes" t a,
+                                     HasCallStack) =>
+                                    ArgsHMap "__backward_npi_tensordot_int_axes" t a ->
+                                      TensorApply t
+__backward_npi_tensordot_int_axes args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_npi_tensordot_int_axes" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_pdf_dirichlet" t = '[]
+
+__backward_pdf_dirichlet ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__backward_pdf_dirichlet" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__backward_pdf_dirichlet" t a -> TensorApply t
+__backward_pdf_dirichlet args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_pdf_dirichlet" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_pdf_exponential" t = '[]
+
+__backward_pdf_exponential ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__backward_pdf_exponential" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__backward_pdf_exponential" t a -> TensorApply t
+__backward_pdf_exponential args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_pdf_exponential" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_pdf_gamma" t = '[]
+
+__backward_pdf_gamma ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_pdf_gamma" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_pdf_gamma" t a -> TensorApply t
+__backward_pdf_gamma args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_pdf_gamma" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__backward_pdf_generalized_negative_binomial" t =
+     '[]
+
+__backward_pdf_generalized_negative_binomial ::
+                                             forall a t .
+                                               (TensorOp t t,
+                                                Fullfilled
+                                                  "__backward_pdf_generalized_negative_binomial" t
+                                                  a,
+                                                HasCallStack) =>
+                                               ArgsHMap
+                                                 "__backward_pdf_generalized_negative_binomial"
+                                                 t
+                                                 a
+                                                 -> TensorApply t
+__backward_pdf_generalized_negative_binomial args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_pdf_generalized_negative_binomial" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_pdf_negative_binomial" t =
+     '[]
+
+__backward_pdf_negative_binomial ::
+                                 forall a t .
+                                   (TensorOp t t, Fullfilled "__backward_pdf_negative_binomial" t a,
+                                    HasCallStack) =>
+                                   ArgsHMap "__backward_pdf_negative_binomial" t a -> TensorApply t
+__backward_pdf_negative_binomial args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_pdf_negative_binomial" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_pdf_normal" t = '[]
+
+__backward_pdf_normal ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_pdf_normal" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_pdf_normal" t a -> TensorApply t
+__backward_pdf_normal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_pdf_normal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_pdf_poisson" t = '[]
+
+__backward_pdf_poisson ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__backward_pdf_poisson" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__backward_pdf_poisson" t a -> TensorApply t
+__backward_pdf_poisson args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_pdf_poisson" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_pdf_uniform" t = '[]
+
+__backward_pdf_uniform ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__backward_pdf_uniform" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__backward_pdf_uniform" t a -> TensorApply t
+__backward_pdf_uniform args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_pdf_uniform" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_pick" t = '[]
+
+__backward_pick ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_pick" t a, HasCallStack) =>
+                  ArgsHMap "__backward_pick" t a -> TensorApply t
+__backward_pick args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_pick" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_power" t = '[]
+
+__backward_power ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__backward_power" t a, HasCallStack) =>
+                   ArgsHMap "__backward_power" t a -> TensorApply t
+__backward_power args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_power" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_power_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t)]
+
+__backward_power_scalar ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__backward_power_scalar" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__backward_power_scalar" t a -> TensorApply t
+__backward_power_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_power_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_prod" t = '[]
+
+__backward_prod ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_prod" t a, HasCallStack) =>
+                  ArgsHMap "__backward_prod" t a -> TensorApply t
+__backward_prod args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_prod" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_radians" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_radians ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_radians" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_radians" t a -> TensorApply t
+__backward_radians args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_radians" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_rcbrt" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_rcbrt ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__backward_rcbrt" t a, HasCallStack) =>
+                   ArgsHMap "__backward_rcbrt" t a -> TensorApply t
+__backward_rcbrt args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_rcbrt" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_rdiv_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t)]
+
+__backward_rdiv_scalar ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__backward_rdiv_scalar" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__backward_rdiv_scalar" t a -> TensorApply t
+__backward_rdiv_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_rdiv_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_reciprocal" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_reciprocal ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_reciprocal" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_reciprocal" t a -> TensorApply t
+__backward_reciprocal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_reciprocal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_relu" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_relu ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_relu" t a, HasCallStack) =>
+                  ArgsHMap "__backward_relu" t a -> TensorApply t
+__backward_relu args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_relu" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_repeat" t = '[]
+
+__backward_repeat ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__backward_repeat" t a, HasCallStack) =>
+                    ArgsHMap "__backward_repeat" t a -> TensorApply t
+__backward_repeat args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_repeat" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_reshape" t = '[]
+
+__backward_reshape ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_reshape" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_reshape" t a -> TensorApply t
+__backward_reshape args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_reshape" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_reverse" t = '[]
+
+__backward_reverse ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_reverse" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_reverse" t a -> TensorApply t
+__backward_reverse args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_reverse" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_rmod_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t)]
+
+__backward_rmod_scalar ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__backward_rmod_scalar" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__backward_rmod_scalar" t a -> TensorApply t
+__backward_rmod_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_rmod_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_rpower_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t)]
+
+__backward_rpower_scalar ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__backward_rpower_scalar" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__backward_rpower_scalar" t a -> TensorApply t
+__backward_rpower_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_rpower_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_rsqrt" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_rsqrt ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__backward_rsqrt" t a, HasCallStack) =>
+                   ArgsHMap "__backward_rsqrt" t a -> TensorApply t
+__backward_rsqrt args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_rsqrt" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_sample_multinomial" t = '[]
+
+__backward_sample_multinomial ::
+                              forall a t .
+                                (TensorOp t t, Fullfilled "__backward_sample_multinomial" t a,
+                                 HasCallStack) =>
+                                ArgsHMap "__backward_sample_multinomial" t a -> TensorApply t
+__backward_sample_multinomial args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_sample_multinomial" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_sigmoid" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_sigmoid ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_sigmoid" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_sigmoid" t a -> TensorApply t
+__backward_sigmoid args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_sigmoid" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_sign" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_sign ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_sign" t a, HasCallStack) =>
+                  ArgsHMap "__backward_sign" t a -> TensorApply t
+__backward_sign args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_sign" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_sin" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_sin ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_sin" t a, HasCallStack) =>
+                 ArgsHMap "__backward_sin" t a -> TensorApply t
+__backward_sin args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_sin" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_sinh" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_sinh ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_sinh" t a, HasCallStack) =>
+                  ArgsHMap "__backward_sinh" t a -> TensorApply t
+__backward_sinh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_sinh" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_slice" t = '[]
+
+__backward_slice ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__backward_slice" t a, HasCallStack) =>
+                   ArgsHMap "__backward_slice" t a -> TensorApply t
+__backward_slice args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_slice" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_slice_axis" t = '[]
+
+__backward_slice_axis ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_slice_axis" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_slice_axis" t a -> TensorApply t
+__backward_slice_axis args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_slice_axis" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_slice_like" t = '[]
+
+__backward_slice_like ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_slice_like" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_slice_like" t a -> TensorApply t
+__backward_slice_like args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_slice_like" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_smooth_l1" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_smooth_l1 ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__backward_smooth_l1" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__backward_smooth_l1" t a -> TensorApply t
+__backward_smooth_l1 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_smooth_l1" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_softmax" t =
+     '[ '("args", AttrOpt [t])]
+
+__backward_softmax ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_softmax" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_softmax" t a -> TensorApply t
+__backward_softmax args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #args :: Maybe [t])
+      in apply "_backward_softmax" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__backward_softmax_cross_entropy" t =
+     '[]
+
+__backward_softmax_cross_entropy ::
+                                 forall a t .
+                                   (TensorOp t t, Fullfilled "__backward_softmax_cross_entropy" t a,
+                                    HasCallStack) =>
+                                   ArgsHMap "__backward_softmax_cross_entropy" t a -> TensorApply t
+__backward_softmax_cross_entropy args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_softmax_cross_entropy" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_softmin" t =
+     '[ '("args", AttrOpt [t])]
+
+__backward_softmin ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_softmin" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_softmin" t a -> TensorApply t
+__backward_softmin args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #args :: Maybe [t])
+      in apply "_backward_softmin" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__backward_softsign" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_softsign ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__backward_softsign" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__backward_softsign" t a -> TensorApply t
+__backward_softsign args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_softsign" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_sparse_retain" t = '[]
+
+__backward_sparse_retain ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__backward_sparse_retain" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__backward_sparse_retain" t a -> TensorApply t
+__backward_sparse_retain args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_sparse_retain" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_sqrt" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_sqrt ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_sqrt" t a, HasCallStack) =>
+                  ArgsHMap "__backward_sqrt" t a -> TensorApply t
+__backward_sqrt args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_sqrt" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_square" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_square ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__backward_square" t a, HasCallStack) =>
+                    ArgsHMap "__backward_square" t a -> TensorApply t
+__backward_square args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_square" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_square_sum" t = '[]
+
+__backward_square_sum ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_square_sum" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_square_sum" t a -> TensorApply t
+__backward_square_sum args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_square_sum" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_squeeze" t = '[]
+
+__backward_squeeze ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__backward_squeeze" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__backward_squeeze" t a -> TensorApply t
+__backward_squeeze args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_squeeze" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_stack" t = '[]
+
+__backward_stack ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__backward_stack" t a, HasCallStack) =>
+                   ArgsHMap "__backward_stack" t a -> TensorApply t
+__backward_stack args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_stack" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_sub" t = '[]
+
+__backward_sub ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_sub" t a, HasCallStack) =>
+                 ArgsHMap "__backward_sub" t a -> TensorApply t
+__backward_sub args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_sub" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_sum" t = '[]
+
+__backward_sum ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_sum" t a, HasCallStack) =>
+                 ArgsHMap "__backward_sum" t a -> TensorApply t
+__backward_sum args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_sum" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_take" t = '[]
+
+__backward_take ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_take" t a, HasCallStack) =>
+                  ArgsHMap "__backward_take" t a -> TensorApply t
+__backward_take args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_take" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_tan" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_tan ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__backward_tan" t a, HasCallStack) =>
+                 ArgsHMap "__backward_tan" t a -> TensorApply t
+__backward_tan args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_tan" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_tanh" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__backward_tanh ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_tanh" t a, HasCallStack) =>
+                  ArgsHMap "__backward_tanh" t a -> TensorApply t
+__backward_tanh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_backward_tanh" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_tile" t = '[]
+
+__backward_tile ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_tile" t a, HasCallStack) =>
+                  ArgsHMap "__backward_tile" t a -> TensorApply t
+__backward_tile args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_tile" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_topk" t = '[]
+
+__backward_topk ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_topk" t a, HasCallStack) =>
+                  ArgsHMap "__backward_topk" t a -> TensorApply t
+__backward_topk args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_topk" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_tril" t = '[]
+
+__backward_tril ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__backward_tril" t a, HasCallStack) =>
+                  ArgsHMap "__backward_tril" t a -> TensorApply t
+__backward_tril args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_tril" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_where" t = '[]
+
+__backward_where ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__backward_where" t a, HasCallStack) =>
+                   ArgsHMap "__backward_where" t a -> TensorApply t
+__backward_where args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_where" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__backward_while_loop" t = '[]
+
+__backward_while_loop ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__backward_while_loop" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__backward_while_loop" t a -> TensorApply t
+__backward_while_loop args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_backward_while_loop" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__broadcast_backward" t = '[]
+
+__broadcast_backward ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__broadcast_backward" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__broadcast_backward" t a -> TensorApply t
+__broadcast_backward args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_broadcast_backward" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_AdaptiveAvgPooling2D" t =
+     '[ '("output_size", AttrOpt [Int]), '("data", AttrOpt t)]
+
+__contrib_AdaptiveAvgPooling2D ::
+                               forall a t .
+                                 (TensorOp t t, Fullfilled "__contrib_AdaptiveAvgPooling2D" t a,
+                                  HasCallStack) =>
+                                 ArgsHMap "__contrib_AdaptiveAvgPooling2D" t a -> TensorApply t
+__contrib_AdaptiveAvgPooling2D args
+  = let scalarArgs
+          = catMaybes
+              [("output_size",) . showValue <$>
+                 (args !? #output_size :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_AdaptiveAvgPooling2D" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_BilinearResize2D" t =
+     '[ '("height", AttrOpt Int), '("width", AttrOpt Int),
+        '("scale_height", AttrOpt (Maybe Float)),
+        '("scale_width", AttrOpt (Maybe Float)),
+        '("mode",
+          AttrOpt
+            (EnumType
+               '["like", "odd_scale", "size", "to_even_down", "to_even_up",
+                 "to_odd_down", "to_odd_up"])),
+        '("data", AttrOpt t), '("like", AttrOpt t)]
+
+__contrib_BilinearResize2D ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__contrib_BilinearResize2D" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__contrib_BilinearResize2D" t a -> TensorApply t
+__contrib_BilinearResize2D args
+  = let scalarArgs
+          = catMaybes
+              [("height",) . showValue <$> (args !? #height :: Maybe Int),
+               ("width",) . showValue <$> (args !? #width :: Maybe Int),
+               ("scale_height",) . showValue <$>
+                 (args !? #scale_height :: Maybe (Maybe Float)),
+               ("scale_width",) . showValue <$>
+                 (args !? #scale_width :: Maybe (Maybe Float)),
+               ("mode",) . showValue <$>
+                 (args !? #mode ::
+                    Maybe
+                      (EnumType
+                         '["like", "odd_scale", "size", "to_even_down", "to_even_up",
+                           "to_odd_down", "to_odd_up"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("like",) <$> (args !? #like :: Maybe t)]
+      in
+      apply "_contrib_BilinearResize2D" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_DeformableConvolution" t =
+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
+        '("num_deformable_group", AttrOpt Int),
+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
+        '("layout", AttrOpt (Maybe (EnumType '["NCDHW", "NCHW", "NCW"]))),
+        '("data", AttrOpt t), '("offset", AttrOpt t),
+        '("weight", AttrOpt t), '("bias", AttrOpt t)]
+
+__contrib_DeformableConvolution ::
+                                forall a t .
+                                  (TensorOp t t, Fullfilled "__contrib_DeformableConvolution" t a,
+                                   HasCallStack) =>
+                                  ArgsHMap "__contrib_DeformableConvolution" t a -> TensorApply t
+__contrib_DeformableConvolution args
+  = let scalarArgs
+          = catMaybes
+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
+               ("num_deformable_group",) . showValue <$>
+                 (args !? #num_deformable_group :: Maybe Int),
+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
+               ("layout",) . showValue <$>
+                 (args !? #layout ::
+                    Maybe (Maybe (EnumType '["NCDHW", "NCHW", "NCW"])))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("offset",) <$> (args !? #offset :: Maybe t),
+               ("weight",) <$> (args !? #weight :: Maybe t),
+               ("bias",) <$> (args !? #bias :: Maybe t)]
+      in
+      apply "_contrib_DeformableConvolution" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_DeformablePSROIPooling" t =
+     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),
+        '("group_size", AttrReq Int), '("pooled_size", AttrReq Int),
+        '("part_size", AttrOpt Int), '("sample_per_part", AttrOpt Int),
+        '("trans_std", AttrOpt Float), '("no_trans", AttrOpt Bool),
+        '("data", AttrOpt t), '("rois", AttrOpt t), '("trans", AttrOpt t)]
+
+__contrib_DeformablePSROIPooling ::
+                                 forall a t .
+                                   (TensorOp t t, Fullfilled "__contrib_DeformablePSROIPooling" t a,
+                                    HasCallStack) =>
+                                   ArgsHMap "__contrib_DeformablePSROIPooling" t a -> TensorApply t
+__contrib_DeformablePSROIPooling args
+  = let scalarArgs
+          = catMaybes
+              [("spatial_scale",) . showValue <$>
+                 (args !? #spatial_scale :: Maybe Float),
+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
+               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int),
+               ("pooled_size",) . showValue <$>
+                 (args !? #pooled_size :: Maybe Int),
+               ("part_size",) . showValue <$> (args !? #part_size :: Maybe Int),
+               ("sample_per_part",) . showValue <$>
+                 (args !? #sample_per_part :: Maybe Int),
+               ("trans_std",) . showValue <$> (args !? #trans_std :: Maybe Float),
+               ("no_trans",) . showValue <$> (args !? #no_trans :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("rois",) <$> (args !? #rois :: Maybe t),
+               ("trans",) <$> (args !? #trans :: Maybe t)]
+      in
+      apply "_contrib_DeformablePSROIPooling" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_MultiBoxDetection" t =
+     '[ '("clip", AttrOpt Bool), '("threshold", AttrOpt Float),
+        '("background_id", AttrOpt Int), '("nms_threshold", AttrOpt Float),
+        '("force_suppress", AttrOpt Bool), '("variances", AttrOpt [Float]),
+        '("nms_topk", AttrOpt Int), '("cls_prob", AttrOpt t),
+        '("loc_pred", AttrOpt t), '("anchor", AttrOpt t)]
+
+__contrib_MultiBoxDetection ::
+                            forall a t .
+                              (TensorOp t t, Fullfilled "__contrib_MultiBoxDetection" t a,
+                               HasCallStack) =>
+                              ArgsHMap "__contrib_MultiBoxDetection" t a -> TensorApply t
+__contrib_MultiBoxDetection args
+  = let scalarArgs
+          = catMaybes
+              [("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
+               ("background_id",) . showValue <$>
+                 (args !? #background_id :: Maybe Int),
+               ("nms_threshold",) . showValue <$>
+                 (args !? #nms_threshold :: Maybe Float),
+               ("force_suppress",) . showValue <$>
+                 (args !? #force_suppress :: Maybe Bool),
+               ("variances",) . showValue <$>
+                 (args !? #variances :: Maybe [Float]),
+               ("nms_topk",) . showValue <$> (args !? #nms_topk :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe t),
+               ("loc_pred",) <$> (args !? #loc_pred :: Maybe t),
+               ("anchor",) <$> (args !? #anchor :: Maybe t)]
+      in
+      apply "_contrib_MultiBoxDetection" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_MultiBoxPrior" t =
+     '[ '("sizes", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
+        '("clip", AttrOpt Bool), '("steps", AttrOpt [Float]),
+        '("offsets", AttrOpt [Float]), '("data", AttrOpt t)]
+
+__contrib_MultiBoxPrior ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__contrib_MultiBoxPrior" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__contrib_MultiBoxPrior" t a -> TensorApply t
+__contrib_MultiBoxPrior args
+  = let scalarArgs
+          = catMaybes
+              [("sizes",) . showValue <$> (args !? #sizes :: Maybe [Float]),
+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
+               ("clip",) . showValue <$> (args !? #clip :: Maybe Bool),
+               ("steps",) . showValue <$> (args !? #steps :: Maybe [Float]),
+               ("offsets",) . showValue <$> (args !? #offsets :: Maybe [Float])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_MultiBoxPrior" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_MultiBoxTarget" t =
+     '[ '("overlap_threshold", AttrOpt Float),
+        '("ignore_label", AttrOpt Float),
+        '("negative_mining_ratio", AttrOpt Float),
+        '("negative_mining_thresh", AttrOpt Float),
+        '("minimum_negative_samples", AttrOpt Int),
+        '("variances", AttrOpt [Float]), '("anchor", AttrOpt t),
+        '("label", AttrOpt t), '("cls_pred", AttrOpt t)]
+
+__contrib_MultiBoxTarget ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__contrib_MultiBoxTarget" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__contrib_MultiBoxTarget" t a -> TensorApply t
+__contrib_MultiBoxTarget args
+  = let scalarArgs
+          = catMaybes
+              [("overlap_threshold",) . showValue <$>
+                 (args !? #overlap_threshold :: Maybe Float),
+               ("ignore_label",) . showValue <$>
+                 (args !? #ignore_label :: Maybe Float),
+               ("negative_mining_ratio",) . showValue <$>
+                 (args !? #negative_mining_ratio :: Maybe Float),
+               ("negative_mining_thresh",) . showValue <$>
+                 (args !? #negative_mining_thresh :: Maybe Float),
+               ("minimum_negative_samples",) . showValue <$>
+                 (args !? #minimum_negative_samples :: Maybe Int),
+               ("variances",) . showValue <$>
+                 (args !? #variances :: Maybe [Float])]
+        tensorKeyArgs
+          = catMaybes
+              [("anchor",) <$> (args !? #anchor :: Maybe t),
+               ("label",) <$> (args !? #label :: Maybe t),
+               ("cls_pred",) <$> (args !? #cls_pred :: Maybe t)]
+      in
+      apply "_contrib_MultiBoxTarget" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_MultiProposal" t =
+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
+        '("rpn_post_nms_top_n", AttrOpt Int),
+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
+        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt t),
+        '("bbox_pred", AttrOpt t), '("im_info", AttrOpt t)]
+
+__contrib_MultiProposal ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__contrib_MultiProposal" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__contrib_MultiProposal" t a -> TensorApply t
+__contrib_MultiProposal args
+  = let scalarArgs
+          = catMaybes
+              [("rpn_pre_nms_top_n",) . showValue <$>
+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
+               ("rpn_post_nms_top_n",) . showValue <$>
+                 (args !? #rpn_post_nms_top_n :: Maybe Int),
+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
+               ("rpn_min_size",) . showValue <$>
+                 (args !? #rpn_min_size :: Maybe Int),
+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
+               ("feature_stride",) . showValue <$>
+                 (args !? #feature_stride :: Maybe Int),
+               ("output_score",) . showValue <$>
+                 (args !? #output_score :: Maybe Bool),
+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe t),
+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe t),
+               ("im_info",) <$> (args !? #im_info :: Maybe t)]
+      in
+      apply "_contrib_MultiProposal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_PSROIPooling" t =
+     '[ '("spatial_scale", AttrReq Float), '("output_dim", AttrReq Int),
+        '("pooled_size", AttrReq Int), '("group_size", AttrOpt Int),
+        '("data", AttrOpt t), '("rois", AttrOpt t)]
+
+__contrib_PSROIPooling ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__contrib_PSROIPooling" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__contrib_PSROIPooling" t a -> TensorApply t
+__contrib_PSROIPooling args
+  = let scalarArgs
+          = catMaybes
+              [("spatial_scale",) . showValue <$>
+                 (args !? #spatial_scale :: Maybe Float),
+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
+               ("pooled_size",) . showValue <$>
+                 (args !? #pooled_size :: Maybe Int),
+               ("group_size",) . showValue <$> (args !? #group_size :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("rois",) <$> (args !? #rois :: Maybe t)]
+      in
+      apply "_contrib_PSROIPooling" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_Proposal" t =
+     '[ '("rpn_pre_nms_top_n", AttrOpt Int),
+        '("rpn_post_nms_top_n", AttrOpt Int),
+        '("threshold", AttrOpt Float), '("rpn_min_size", AttrOpt Int),
+        '("scales", AttrOpt [Float]), '("ratios", AttrOpt [Float]),
+        '("feature_stride", AttrOpt Int), '("output_score", AttrOpt Bool),
+        '("iou_loss", AttrOpt Bool), '("cls_prob", AttrOpt t),
+        '("bbox_pred", AttrOpt t), '("im_info", AttrOpt t)]
+
+__contrib_Proposal ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__contrib_Proposal" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__contrib_Proposal" t a -> TensorApply t
+__contrib_Proposal args
+  = let scalarArgs
+          = catMaybes
+              [("rpn_pre_nms_top_n",) . showValue <$>
+                 (args !? #rpn_pre_nms_top_n :: Maybe Int),
+               ("rpn_post_nms_top_n",) . showValue <$>
+                 (args !? #rpn_post_nms_top_n :: Maybe Int),
+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
+               ("rpn_min_size",) . showValue <$>
+                 (args !? #rpn_min_size :: Maybe Int),
+               ("scales",) . showValue <$> (args !? #scales :: Maybe [Float]),
+               ("ratios",) . showValue <$> (args !? #ratios :: Maybe [Float]),
+               ("feature_stride",) . showValue <$>
+                 (args !? #feature_stride :: Maybe Int),
+               ("output_score",) . showValue <$>
+                 (args !? #output_score :: Maybe Bool),
+               ("iou_loss",) . showValue <$> (args !? #iou_loss :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("cls_prob",) <$> (args !? #cls_prob :: Maybe t),
+               ("bbox_pred",) <$> (args !? #bbox_pred :: Maybe t),
+               ("im_info",) <$> (args !? #im_info :: Maybe t)]
+      in
+      apply "_contrib_Proposal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_ROIAlign" t =
+     '[ '("pooled_size", AttrReq [Int]),
+        '("spatial_scale", AttrReq Float), '("sample_ratio", AttrOpt Int),
+        '("position_sensitive", AttrOpt Bool), '("data", AttrOpt t),
+        '("rois", AttrOpt t)]
+
+__contrib_ROIAlign ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__contrib_ROIAlign" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__contrib_ROIAlign" t a -> TensorApply t
+__contrib_ROIAlign args
+  = let scalarArgs
+          = catMaybes
+              [("pooled_size",) . showValue <$>
+                 (args !? #pooled_size :: Maybe [Int]),
+               ("spatial_scale",) . showValue <$>
+                 (args !? #spatial_scale :: Maybe Float),
+               ("sample_ratio",) . showValue <$>
+                 (args !? #sample_ratio :: Maybe Int),
+               ("position_sensitive",) . showValue <$>
+                 (args !? #position_sensitive :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("rois",) <$> (args !? #rois :: Maybe t)]
+      in
+      apply "_contrib_ROIAlign" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_RROIAlign" t =
+     '[ '("pooled_size", AttrReq [Int]),
+        '("spatial_scale", AttrReq Float),
+        '("sampling_ratio", AttrOpt Int), '("data", AttrOpt t),
+        '("rois", AttrOpt t)]
+
+__contrib_RROIAlign ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__contrib_RROIAlign" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__contrib_RROIAlign" t a -> TensorApply t
+__contrib_RROIAlign args
+  = let scalarArgs
+          = catMaybes
+              [("pooled_size",) . showValue <$>
+                 (args !? #pooled_size :: Maybe [Int]),
+               ("spatial_scale",) . showValue <$>
+                 (args !? #spatial_scale :: Maybe Float),
+               ("sampling_ratio",) . showValue <$>
+                 (args !? #sampling_ratio :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("rois",) <$> (args !? #rois :: Maybe t)]
+      in
+      apply "_contrib_RROIAlign" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_SparseEmbedding" t =
+     '[ '("input_dim", AttrReq Int), '("output_dim", AttrReq Int),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "int8",
+                 "uint8"])),
+        '("sparse_grad", AttrOpt Bool), '("data", AttrOpt t),
+        '("weight", AttrOpt t)]
+
+__contrib_SparseEmbedding ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "__contrib_SparseEmbedding" t a,
+                             HasCallStack) =>
+                            ArgsHMap "__contrib_SparseEmbedding" t a -> TensorApply t
+__contrib_SparseEmbedding args
+  = let scalarArgs
+          = catMaybes
+              [("input_dim",) . showValue <$> (args !? #input_dim :: Maybe Int),
+               ("output_dim",) . showValue <$> (args !? #output_dim :: Maybe Int),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "int8",
+                           "uint8"])),
+               ("sparse_grad",) . showValue <$>
+                 (args !? #sparse_grad :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("weight",) <$> (args !? #weight :: Maybe t)]
+      in
+      apply "_contrib_SparseEmbedding" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_SyncBatchNorm" t =
+     '[ '("eps", AttrOpt Float), '("momentum", AttrOpt Float),
+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
+        '("output_mean_var", AttrOpt Bool), '("ndev", AttrOpt Int),
+        '("key", AttrReq Text), '("data", AttrOpt t),
+        '("gamma", AttrOpt t), '("beta", AttrOpt t),
+        '("moving_mean", AttrOpt t), '("moving_var", AttrOpt t)]
+
+__contrib_SyncBatchNorm ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__contrib_SyncBatchNorm" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__contrib_SyncBatchNorm" t a -> TensorApply t
+__contrib_SyncBatchNorm args
+  = let scalarArgs
+          = catMaybes
+              [("eps",) . showValue <$> (args !? #eps :: Maybe Float),
+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
+               ("use_global_stats",) . showValue <$>
+                 (args !? #use_global_stats :: Maybe Bool),
+               ("output_mean_var",) . showValue <$>
+                 (args !? #output_mean_var :: Maybe Bool),
+               ("ndev",) . showValue <$> (args !? #ndev :: Maybe Int),
+               ("key",) . showValue <$> (args !? #key :: Maybe Text)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("gamma",) <$> (args !? #gamma :: Maybe t),
+               ("beta",) <$> (args !? #beta :: Maybe t),
+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe t),
+               ("moving_var",) <$> (args !? #moving_var :: Maybe t)]
+      in
+      apply "_contrib_SyncBatchNorm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_allclose" t =
+     '[ '("rtol", AttrOpt Float), '("atol", AttrOpt Float),
+        '("equal_nan", AttrOpt Bool), '("a", AttrOpt t), '("b", AttrOpt t)]
+
+__contrib_allclose ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__contrib_allclose" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__contrib_allclose" t a -> TensorApply t
+__contrib_allclose args
+  = let scalarArgs
+          = catMaybes
+              [("rtol",) . showValue <$> (args !? #rtol :: Maybe Float),
+               ("atol",) . showValue <$> (args !? #atol :: Maybe Float),
+               ("equal_nan",) . showValue <$> (args !? #equal_nan :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("a",) <$> (args !? #a :: Maybe t),
+               ("b",) <$> (args !? #b :: Maybe t)]
+      in
+      apply "_contrib_allclose" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_arange_like" t =
+     '[ '("start", AttrOpt Double), '("step", AttrOpt Double),
+        '("repeat", AttrOpt Int), '("ctx", AttrOpt Text),
+        '("axis", AttrOpt (Maybe Int)), '("data", AttrOpt t)]
+
+__contrib_arange_like ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__contrib_arange_like" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__contrib_arange_like" t a -> TensorApply t
+__contrib_arange_like args
+  = let scalarArgs
+          = catMaybes
+              [("start",) . showValue <$> (args !? #start :: Maybe Double),
+               ("step",) . showValue <$> (args !? #step :: Maybe Double),
+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_arange_like" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__contrib_backward_gradientmultiplier" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__contrib_backward_gradientmultiplier ::
+                                      forall a t .
+                                        (TensorOp t t,
+                                         Fullfilled "__contrib_backward_gradientmultiplier" t a,
+                                         HasCallStack) =>
+                                        ArgsHMap "__contrib_backward_gradientmultiplier" t a ->
+                                          TensorApply t
+__contrib_backward_gradientmultiplier args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_backward_gradientmultiplier" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_backward_hawkesll" t = '[]
+
+__contrib_backward_hawkesll ::
+                            forall a t .
+                              (TensorOp t t, Fullfilled "__contrib_backward_hawkesll" t a,
+                               HasCallStack) =>
+                              ArgsHMap "__contrib_backward_hawkesll" t a -> TensorApply t
+__contrib_backward_hawkesll args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_contrib_backward_hawkesll" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_backward_index_copy" t = '[]
+
+__contrib_backward_index_copy ::
+                              forall a t .
+                                (TensorOp t t, Fullfilled "__contrib_backward_index_copy" t a,
+                                 HasCallStack) =>
+                                ArgsHMap "__contrib_backward_index_copy" t a -> TensorApply t
+__contrib_backward_index_copy args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_contrib_backward_index_copy" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_backward_quadratic" t = '[]
+
+__contrib_backward_quadratic ::
+                             forall a t .
+                               (TensorOp t t, Fullfilled "__contrib_backward_quadratic" t a,
+                                HasCallStack) =>
+                               ArgsHMap "__contrib_backward_quadratic" t a -> TensorApply t
+__contrib_backward_quadratic args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_contrib_backward_quadratic" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_bipartite_matching" t =
+     '[ '("is_ascend", AttrOpt Bool), '("threshold", AttrReq Float),
+        '("topk", AttrOpt Int), '("data", AttrOpt t)]
+
+__contrib_bipartite_matching ::
+                             forall a t .
+                               (TensorOp t t, Fullfilled "__contrib_bipartite_matching" t a,
+                                HasCallStack) =>
+                               ArgsHMap "__contrib_bipartite_matching" t a -> TensorApply t
+__contrib_bipartite_matching args
+  = let scalarArgs
+          = catMaybes
+              [("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
+               ("threshold",) . showValue <$> (args !? #threshold :: Maybe Float),
+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_bipartite_matching" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_boolean_mask" t =
+     '[ '("axis", AttrOpt Int), '("data", AttrOpt t),
+        '("index", AttrOpt t)]
+
+__contrib_boolean_mask ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__contrib_boolean_mask" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__contrib_boolean_mask" t a -> TensorApply t
+__contrib_boolean_mask args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("index",) <$> (args !? #index :: Maybe t)]
+      in
+      apply "_contrib_boolean_mask" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_box_decode" t =
+     '[ '("std0", AttrOpt Float), '("std1", AttrOpt Float),
+        '("std2", AttrOpt Float), '("std3", AttrOpt Float),
+        '("clip", AttrOpt Float),
+        '("format", AttrOpt (EnumType '["center", "corner"])),
+        '("data", AttrOpt t), '("anchors", AttrOpt t)]
+
+__contrib_box_decode ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__contrib_box_decode" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__contrib_box_decode" t a -> TensorApply t
+__contrib_box_decode args
+  = let scalarArgs
+          = catMaybes
+              [("std0",) . showValue <$> (args !? #std0 :: Maybe Float),
+               ("std1",) . showValue <$> (args !? #std1 :: Maybe Float),
+               ("std2",) . showValue <$> (args !? #std2 :: Maybe Float),
+               ("std3",) . showValue <$> (args !? #std3 :: Maybe Float),
+               ("clip",) . showValue <$> (args !? #clip :: Maybe Float),
+               ("format",) . showValue <$>
+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("anchors",) <$> (args !? #anchors :: Maybe t)]
+      in
+      apply "_contrib_box_decode" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_box_encode" t =
+     '[ '("samples", AttrOpt t), '("matches", AttrOpt t),
+        '("anchors", AttrOpt t), '("refs", AttrOpt t),
+        '("means", AttrOpt t), '("stds", AttrOpt t)]
+
+__contrib_box_encode ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__contrib_box_encode" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__contrib_box_encode" t a -> TensorApply t
+__contrib_box_encode args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("samples",) <$> (args !? #samples :: Maybe t),
+               ("matches",) <$> (args !? #matches :: Maybe t),
+               ("anchors",) <$> (args !? #anchors :: Maybe t),
+               ("refs",) <$> (args !? #refs :: Maybe t),
+               ("means",) <$> (args !? #means :: Maybe t),
+               ("stds",) <$> (args !? #stds :: Maybe t)]
+      in
+      apply "_contrib_box_encode" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_box_iou" t =
+     '[ '("format", AttrOpt (EnumType '["center", "corner"])),
+        '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__contrib_box_iou ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__contrib_box_iou" t a, HasCallStack) =>
+                    ArgsHMap "__contrib_box_iou" t a -> TensorApply t
+__contrib_box_iou args
+  = let scalarArgs
+          = catMaybes
+              [("format",) . showValue <$>
+                 (args !? #format :: Maybe (EnumType '["center", "corner"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_contrib_box_iou" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_box_nms" t =
+     '[ '("overlap_thresh", AttrOpt Float),
+        '("valid_thresh", AttrOpt Float), '("topk", AttrOpt Int),
+        '("coord_start", AttrOpt Int), '("score_index", AttrOpt Int),
+        '("id_index", AttrOpt Int), '("background_id", AttrOpt Int),
+        '("force_suppress", AttrOpt Bool),
+        '("in_format", AttrOpt (EnumType '["center", "corner"])),
+        '("out_format", AttrOpt (EnumType '["center", "corner"])),
+        '("data", AttrOpt t)]
+
+__contrib_box_nms ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__contrib_box_nms" t a, HasCallStack) =>
+                    ArgsHMap "__contrib_box_nms" t a -> TensorApply t
+__contrib_box_nms args
+  = let scalarArgs
+          = catMaybes
+              [("overlap_thresh",) . showValue <$>
+                 (args !? #overlap_thresh :: Maybe Float),
+               ("valid_thresh",) . showValue <$>
+                 (args !? #valid_thresh :: Maybe Float),
+               ("topk",) . showValue <$> (args !? #topk :: Maybe Int),
+               ("coord_start",) . showValue <$>
+                 (args !? #coord_start :: Maybe Int),
+               ("score_index",) . showValue <$>
+                 (args !? #score_index :: Maybe Int),
+               ("id_index",) . showValue <$> (args !? #id_index :: Maybe Int),
+               ("background_id",) . showValue <$>
+                 (args !? #background_id :: Maybe Int),
+               ("force_suppress",) . showValue <$>
+                 (args !? #force_suppress :: Maybe Bool),
+               ("in_format",) . showValue <$>
+                 (args !? #in_format :: Maybe (EnumType '["center", "corner"])),
+               ("out_format",) . showValue <$>
+                 (args !? #out_format :: Maybe (EnumType '["center", "corner"]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_box_nms" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_calibrate_entropy" t =
+     '[ '("num_quantized_bins", AttrOpt Int), '("hist", AttrOpt t),
+        '("hist_edges", AttrOpt t)]
+
+__contrib_calibrate_entropy ::
+                            forall a t .
+                              (TensorOp t t, Fullfilled "__contrib_calibrate_entropy" t a,
+                               HasCallStack) =>
+                              ArgsHMap "__contrib_calibrate_entropy" t a -> TensorApply t
+__contrib_calibrate_entropy args
+  = let scalarArgs
+          = catMaybes
+              [("num_quantized_bins",) . showValue <$>
+                 (args !? #num_quantized_bins :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("hist",) <$> (args !? #hist :: Maybe t),
+               ("hist_edges",) <$> (args !? #hist_edges :: Maybe t)]
+      in
+      apply "_contrib_calibrate_entropy" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_count_sketch" t =
+     '[ '("out_dim", AttrReq Int),
+        '("processing_batch_size", AttrOpt Int), '("data", AttrOpt t),
+        '("h", AttrOpt t), '("s", AttrOpt t)]
+
+__contrib_count_sketch ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__contrib_count_sketch" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__contrib_count_sketch" t a -> TensorApply t
+__contrib_count_sketch args
+  = let scalarArgs
+          = catMaybes
+              [("out_dim",) . showValue <$> (args !? #out_dim :: Maybe Int),
+               ("processing_batch_size",) . showValue <$>
+                 (args !? #processing_batch_size :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("h",) <$> (args !? #h :: Maybe t),
+               ("s",) <$> (args !? #s :: Maybe t)]
+      in
+      apply "_contrib_count_sketch" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_dequantize" t =
+     '[ '("out_type", AttrOpt (EnumType '["float32"])),
+        '("data", AttrOpt t), '("min_range", AttrOpt t),
+        '("max_range", AttrOpt t)]
+
+__contrib_dequantize ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__contrib_dequantize" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__contrib_dequantize" t a -> TensorApply t
+__contrib_dequantize args
+  = let scalarArgs
+          = catMaybes
+              [("out_type",) . showValue <$>
+                 (args !? #out_type :: Maybe (EnumType '["float32"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("min_range",) <$> (args !? #min_range :: Maybe t),
+               ("max_range",) <$> (args !? #max_range :: Maybe t)]
+      in
+      apply "_contrib_dequantize" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_dgl_adjacency" t =
+     '[ '("data", AttrOpt t)]
+
+__contrib_dgl_adjacency ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__contrib_dgl_adjacency" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__contrib_dgl_adjacency" t a -> TensorApply t
+__contrib_dgl_adjacency args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_dgl_adjacency" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_div_sqrt_dim" t =
+     '[ '("data", AttrOpt t)]
+
+__contrib_div_sqrt_dim ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__contrib_div_sqrt_dim" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__contrib_div_sqrt_dim" t a -> TensorApply t
+__contrib_div_sqrt_dim args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_div_sqrt_dim" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_edge_id" t =
+     '[ '("data", AttrOpt t), '("u", AttrOpt t), '("v", AttrOpt t)]
+
+__contrib_edge_id ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__contrib_edge_id" t a, HasCallStack) =>
+                    ArgsHMap "__contrib_edge_id" t a -> TensorApply t
+__contrib_edge_id args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("u",) <$> (args !? #u :: Maybe t),
+               ("v",) <$> (args !? #v :: Maybe t)]
+      in
+      apply "_contrib_edge_id" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_fft" t =
+     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt t)]
+
+__contrib_fft ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__contrib_fft" t a, HasCallStack) =>
+                ArgsHMap "__contrib_fft" t a -> TensorApply t
+__contrib_fft args
+  = let scalarArgs
+          = catMaybes
+              [("compute_size",) . showValue <$>
+                 (args !? #compute_size :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_fft" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_getnnz" t =
+     '[ '("axis", AttrOpt (Maybe Int)), '("data", AttrOpt t)]
+
+__contrib_getnnz ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__contrib_getnnz" t a, HasCallStack) =>
+                   ArgsHMap "__contrib_getnnz" t a -> TensorApply t
+__contrib_getnnz args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_getnnz" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_gradientmultiplier" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__contrib_gradientmultiplier ::
+                             forall a t .
+                               (TensorOp t t, Fullfilled "__contrib_gradientmultiplier" t a,
+                                HasCallStack) =>
+                               ArgsHMap "__contrib_gradientmultiplier" t a -> TensorApply t
+__contrib_gradientmultiplier args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_gradientmultiplier" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_group_adagrad_update" t =
+     '[ '("lr", AttrReq Float), '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("epsilon", AttrOpt Float),
+        '("weight", AttrOpt t), '("grad", AttrOpt t),
+        '("history", AttrOpt t)]
+
+__contrib_group_adagrad_update ::
+                               forall a t .
+                                 (TensorOp t t, Fullfilled "__contrib_group_adagrad_update" t a,
+                                  HasCallStack) =>
+                                 ArgsHMap "__contrib_group_adagrad_update" t a -> TensorApply t
+__contrib_group_adagrad_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("history",) <$> (args !? #history :: Maybe t)]
+      in
+      apply "_contrib_group_adagrad_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_hawkesll" t =
+     '[ '("lda", AttrOpt t), '("alpha", AttrOpt t),
+        '("beta", AttrOpt t), '("state", AttrOpt t), '("lags", AttrOpt t),
+        '("marks", AttrOpt t), '("valid_length", AttrOpt t),
+        '("max_time", AttrOpt t)]
+
+__contrib_hawkesll ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__contrib_hawkesll" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__contrib_hawkesll" t a -> TensorApply t
+__contrib_hawkesll args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lda",) <$> (args !? #lda :: Maybe t),
+               ("alpha",) <$> (args !? #alpha :: Maybe t),
+               ("beta",) <$> (args !? #beta :: Maybe t),
+               ("state",) <$> (args !? #state :: Maybe t),
+               ("lags",) <$> (args !? #lags :: Maybe t),
+               ("marks",) <$> (args !? #marks :: Maybe t),
+               ("valid_length",) <$> (args !? #valid_length :: Maybe t),
+               ("max_time",) <$> (args !? #max_time :: Maybe t)]
+      in
+      apply "_contrib_hawkesll" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_ifft" t =
+     '[ '("compute_size", AttrOpt Int), '("data", AttrOpt t)]
+
+__contrib_ifft ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__contrib_ifft" t a, HasCallStack) =>
+                 ArgsHMap "__contrib_ifft" t a -> TensorApply t
+__contrib_ifft args
+  = let scalarArgs
+          = catMaybes
+              [("compute_size",) . showValue <$>
+                 (args !? #compute_size :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_ifft" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_index_array" t =
+     '[ '("axes", AttrOpt (Maybe [Int])), '("data", AttrOpt t)]
+
+__contrib_index_array ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__contrib_index_array" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__contrib_index_array" t a -> TensorApply t
+__contrib_index_array args
+  = let scalarArgs
+          = catMaybes
+              [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_index_array" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_index_copy" t =
+     '[ '("old_tensor", AttrOpt t), '("index_vector", AttrOpt t),
+        '("new_tensor", AttrOpt t)]
+
+__contrib_index_copy ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__contrib_index_copy" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__contrib_index_copy" t a -> TensorApply t
+__contrib_index_copy args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("old_tensor",) <$> (args !? #old_tensor :: Maybe t),
+               ("index_vector",) <$> (args !? #index_vector :: Maybe t),
+               ("new_tensor",) <$> (args !? #new_tensor :: Maybe t)]
+      in
+      apply "_contrib_index_copy" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__contrib_interleaved_matmul_encdec_qk" t =
+     '[ '("heads", AttrReq Int), '("queries", AttrOpt t),
+        '("keys_values", AttrOpt t)]
+
+__contrib_interleaved_matmul_encdec_qk ::
+                                       forall a t .
+                                         (TensorOp t t,
+                                          Fullfilled "__contrib_interleaved_matmul_encdec_qk" t a,
+                                          HasCallStack) =>
+                                         ArgsHMap "__contrib_interleaved_matmul_encdec_qk" t a ->
+                                           TensorApply t
+__contrib_interleaved_matmul_encdec_qk args
+  = let scalarArgs
+          = catMaybes
+              [("heads",) . showValue <$> (args !? #heads :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("queries",) <$> (args !? #queries :: Maybe t),
+               ("keys_values",) <$> (args !? #keys_values :: Maybe t)]
+      in
+      apply "_contrib_interleaved_matmul_encdec_qk" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__contrib_interleaved_matmul_encdec_valatt" t =
+     '[ '("heads", AttrReq Int), '("keys_values", AttrOpt t),
+        '("attention", AttrOpt t)]
+
+__contrib_interleaved_matmul_encdec_valatt ::
+                                           forall a t .
+                                             (TensorOp t t,
+                                              Fullfilled
+                                                "__contrib_interleaved_matmul_encdec_valatt" t a,
+                                              HasCallStack) =>
+                                             ArgsHMap "__contrib_interleaved_matmul_encdec_valatt" t
+                                               a
+                                               -> TensorApply t
+__contrib_interleaved_matmul_encdec_valatt args
+  = let scalarArgs
+          = catMaybes
+              [("heads",) . showValue <$> (args !? #heads :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("keys_values",) <$> (args !? #keys_values :: Maybe t),
+               ("attention",) <$> (args !? #attention :: Maybe t)]
+      in
+      apply "_contrib_interleaved_matmul_encdec_valatt" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__contrib_interleaved_matmul_selfatt_qk" t =
+     '[ '("heads", AttrReq Int), '("queries_keys_values", AttrOpt t)]
+
+__contrib_interleaved_matmul_selfatt_qk ::
+                                        forall a t .
+                                          (TensorOp t t,
+                                           Fullfilled "__contrib_interleaved_matmul_selfatt_qk" t a,
+                                           HasCallStack) =>
+                                          ArgsHMap "__contrib_interleaved_matmul_selfatt_qk" t a ->
+                                            TensorApply t
+__contrib_interleaved_matmul_selfatt_qk args
+  = let scalarArgs
+          = catMaybes
+              [("heads",) . showValue <$> (args !? #heads :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("queries_keys_values",) <$>
+                 (args !? #queries_keys_values :: Maybe t)]
+      in
+      apply "_contrib_interleaved_matmul_selfatt_qk" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__contrib_interleaved_matmul_selfatt_valatt" t =
+     '[ '("heads", AttrReq Int), '("queries_keys_values", AttrOpt t),
+        '("attention", AttrOpt t)]
+
+__contrib_interleaved_matmul_selfatt_valatt ::
+                                            forall a t .
+                                              (TensorOp t t,
+                                               Fullfilled
+                                                 "__contrib_interleaved_matmul_selfatt_valatt" t a,
+                                               HasCallStack) =>
+                                              ArgsHMap "__contrib_interleaved_matmul_selfatt_valatt"
+                                                t
+                                                a
+                                                -> TensorApply t
+__contrib_interleaved_matmul_selfatt_valatt args
+  = let scalarArgs
+          = catMaybes
+              [("heads",) . showValue <$> (args !? #heads :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("queries_keys_values",) <$>
+                 (args !? #queries_keys_values :: Maybe t),
+               ("attention",) <$> (args !? #attention :: Maybe t)]
+      in
+      apply "_contrib_interleaved_matmul_selfatt_valatt" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_mrcnn_mask_target" t =
+     '[ '("num_rois", AttrReq Int), '("num_classes", AttrReq Int),
+        '("mask_size", AttrReq [Int]), '("sample_ratio", AttrOpt Int),
+        '("rois", AttrOpt t), '("gt_masks", AttrOpt t),
+        '("matches", AttrOpt t), '("cls_targets", AttrOpt t)]
+
+__contrib_mrcnn_mask_target ::
+                            forall a t .
+                              (TensorOp t t, Fullfilled "__contrib_mrcnn_mask_target" t a,
+                               HasCallStack) =>
+                              ArgsHMap "__contrib_mrcnn_mask_target" t a -> TensorApply t
+__contrib_mrcnn_mask_target args
+  = let scalarArgs
+          = catMaybes
+              [("num_rois",) . showValue <$> (args !? #num_rois :: Maybe Int),
+               ("num_classes",) . showValue <$>
+                 (args !? #num_classes :: Maybe Int),
+               ("mask_size",) . showValue <$> (args !? #mask_size :: Maybe [Int]),
+               ("sample_ratio",) . showValue <$>
+                 (args !? #sample_ratio :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("rois",) <$> (args !? #rois :: Maybe t),
+               ("gt_masks",) <$> (args !? #gt_masks :: Maybe t),
+               ("matches",) <$> (args !? #matches :: Maybe t),
+               ("cls_targets",) <$> (args !? #cls_targets :: Maybe t)]
+      in
+      apply "_contrib_mrcnn_mask_target" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_quadratic" t =
+     '[ '("a", AttrOpt Float), '("b", AttrOpt Float),
+        '("c", AttrOpt Float), '("data", AttrOpt t)]
+
+__contrib_quadratic ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__contrib_quadratic" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__contrib_quadratic" t a -> TensorApply t
+__contrib_quadratic args
+  = let scalarArgs
+          = catMaybes
+              [("a",) . showValue <$> (args !? #a :: Maybe Float),
+               ("b",) . showValue <$> (args !? #b :: Maybe Float),
+               ("c",) . showValue <$> (args !? #c :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_quadratic" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_quantize" t =
+     '[ '("out_type", AttrOpt (EnumType '["int8", "uint8"])),
+        '("data", AttrOpt t), '("min_range", AttrOpt t),
+        '("max_range", AttrOpt t)]
+
+__contrib_quantize ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__contrib_quantize" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__contrib_quantize" t a -> TensorApply t
+__contrib_quantize args
+  = let scalarArgs
+          = catMaybes
+              [("out_type",) . showValue <$>
+                 (args !? #out_type :: Maybe (EnumType '["int8", "uint8"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("min_range",) <$> (args !? #min_range :: Maybe t),
+               ("max_range",) <$> (args !? #max_range :: Maybe t)]
+      in
+      apply "_contrib_quantize" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_quantize_v2" t =
+     '[ '("out_type", AttrOpt (EnumType '["auto", "int8", "uint8"])),
+        '("min_calib_range", AttrOpt (Maybe Float)),
+        '("max_calib_range", AttrOpt (Maybe Float)), '("data", AttrOpt t)]
+
+__contrib_quantize_v2 ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__contrib_quantize_v2" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__contrib_quantize_v2" t a -> TensorApply t
+__contrib_quantize_v2 args
+  = let scalarArgs
+          = catMaybes
+              [("out_type",) . showValue <$>
+                 (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])),
+               ("min_calib_range",) . showValue <$>
+                 (args !? #min_calib_range :: Maybe (Maybe Float)),
+               ("max_calib_range",) . showValue <$>
+                 (args !? #max_calib_range :: Maybe (Maybe Float))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_quantize_v2" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_quantized_act" t =
+     '[ '("act_type",
+          AttrReq
+            (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"])),
+        '("data", AttrOpt t), '("min_data", AttrOpt t),
+        '("max_data", AttrOpt t)]
+
+__contrib_quantized_act ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__contrib_quantized_act" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__contrib_quantized_act" t a -> TensorApply t
+__contrib_quantized_act args
+  = let scalarArgs
+          = catMaybes
+              [("act_type",) . showValue <$>
+                 (args !? #act_type ::
+                    Maybe
+                      (EnumType '["relu", "sigmoid", "softrelu", "softsign", "tanh"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("min_data",) <$> (args !? #min_data :: Maybe t),
+               ("max_data",) <$> (args !? #max_data :: Maybe t)]
+      in
+      apply "_contrib_quantized_act" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_quantized_batch_norm" t =
+     '[ '("eps", AttrOpt Double), '("momentum", AttrOpt Float),
+        '("fix_gamma", AttrOpt Bool), '("use_global_stats", AttrOpt Bool),
+        '("output_mean_var", AttrOpt Bool), '("axis", AttrOpt Int),
+        '("cudnn_off", AttrOpt Bool),
+        '("min_calib_range", AttrOpt (Maybe Float)),
+        '("max_calib_range", AttrOpt (Maybe Float)), '("data", AttrOpt t),
+        '("gamma", AttrOpt t), '("beta", AttrOpt t),
+        '("moving_mean", AttrOpt t), '("moving_var", AttrOpt t),
+        '("min_data", AttrOpt t), '("max_data", AttrOpt t)]
+
+__contrib_quantized_batch_norm ::
+                               forall a t .
+                                 (TensorOp t t, Fullfilled "__contrib_quantized_batch_norm" t a,
+                                  HasCallStack) =>
+                                 ArgsHMap "__contrib_quantized_batch_norm" t a -> TensorApply t
+__contrib_quantized_batch_norm args
+  = let scalarArgs
+          = catMaybes
+              [("eps",) . showValue <$> (args !? #eps :: Maybe Double),
+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
+               ("fix_gamma",) . showValue <$> (args !? #fix_gamma :: Maybe Bool),
+               ("use_global_stats",) . showValue <$>
+                 (args !? #use_global_stats :: Maybe Bool),
+               ("output_mean_var",) . showValue <$>
+                 (args !? #output_mean_var :: Maybe Bool),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
+               ("min_calib_range",) . showValue <$>
+                 (args !? #min_calib_range :: Maybe (Maybe Float)),
+               ("max_calib_range",) . showValue <$>
+                 (args !? #max_calib_range :: Maybe (Maybe Float))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("gamma",) <$> (args !? #gamma :: Maybe t),
+               ("beta",) <$> (args !? #beta :: Maybe t),
+               ("moving_mean",) <$> (args !? #moving_mean :: Maybe t),
+               ("moving_var",) <$> (args !? #moving_var :: Maybe t),
+               ("min_data",) <$> (args !? #min_data :: Maybe t),
+               ("max_data",) <$> (args !? #max_data :: Maybe t)]
+      in
+      apply "_contrib_quantized_batch_norm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_quantized_concat" t =
+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+__contrib_quantized_concat ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__contrib_quantized_concat" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__contrib_quantized_concat" t a -> TensorApply t
+__contrib_quantized_concat args
+  = let scalarArgs
+          = catMaybes
+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in
+      apply "_contrib_quantized_concat" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__contrib_quantized_conv" t =
+     '[ '("kernel", AttrReq [Int]), '("stride", AttrOpt [Int]),
+        '("dilate", AttrOpt [Int]), '("pad", AttrOpt [Int]),
+        '("num_filter", AttrReq Int), '("num_group", AttrOpt Int),
+        '("workspace", AttrOpt Int), '("no_bias", AttrOpt Bool),
+        '("cudnn_tune",
+          AttrOpt
+            (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
+        '("cudnn_off", AttrOpt Bool),
+        '("layout",
+          AttrOpt
+            (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"]))),
+        '("data", AttrOpt t), '("weight", AttrOpt t), '("bias", AttrOpt t),
+        '("min_data", AttrOpt t), '("max_data", AttrOpt t),
+        '("min_weight", AttrOpt t), '("max_weight", AttrOpt t),
+        '("min_bias", AttrOpt t), '("max_bias", AttrOpt t)]
+
+__contrib_quantized_conv ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__contrib_quantized_conv" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__contrib_quantized_conv" t a -> TensorApply t
+__contrib_quantized_conv args
+  = let scalarArgs
+          = catMaybes
+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
+               ("dilate",) . showValue <$> (args !? #dilate :: Maybe [Int]),
+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
+               ("num_filter",) . showValue <$> (args !? #num_filter :: Maybe Int),
+               ("num_group",) . showValue <$> (args !? #num_group :: Maybe Int),
+               ("workspace",) . showValue <$> (args !? #workspace :: Maybe Int),
+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
+               ("cudnn_tune",) . showValue <$>
+                 (args !? #cudnn_tune ::
+                    Maybe (Maybe (EnumType '["fastest", "limited_workspace", "off"]))),
+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
+               ("layout",) . showValue <$>
+                 (args !? #layout ::
+                    Maybe
+                      (Maybe (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC"])))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("weight",) <$> (args !? #weight :: Maybe t),
+               ("bias",) <$> (args !? #bias :: Maybe t),
+               ("min_data",) <$> (args !? #min_data :: Maybe t),
+               ("max_data",) <$> (args !? #max_data :: Maybe t),
+               ("min_weight",) <$> (args !? #min_weight :: Maybe t),
+               ("max_weight",) <$> (args !? #max_weight :: Maybe t),
+               ("min_bias",) <$> (args !? #min_bias :: Maybe t),
+               ("max_bias",) <$> (args !? #max_bias :: Maybe t)]
+      in
+      apply "_contrib_quantized_conv" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_quantized_elemwise_add" t =
+     '[ '("min_calib_range", AttrOpt (Maybe Float)),
+        '("max_calib_range", AttrOpt (Maybe Float)), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t), '("lhs_min", AttrOpt t),
+        '("lhs_max", AttrOpt t), '("rhs_min", AttrOpt t),
+        '("rhs_max", AttrOpt t)]
+
+__contrib_quantized_elemwise_add ::
+                                 forall a t .
+                                   (TensorOp t t, Fullfilled "__contrib_quantized_elemwise_add" t a,
+                                    HasCallStack) =>
+                                   ArgsHMap "__contrib_quantized_elemwise_add" t a -> TensorApply t
+__contrib_quantized_elemwise_add args
+  = let scalarArgs
+          = catMaybes
+              [("min_calib_range",) . showValue <$>
+                 (args !? #min_calib_range :: Maybe (Maybe Float)),
+               ("max_calib_range",) . showValue <$>
+                 (args !? #max_calib_range :: Maybe (Maybe Float))]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t),
+               ("lhs_min",) <$> (args !? #lhs_min :: Maybe t),
+               ("lhs_max",) <$> (args !? #lhs_max :: Maybe t),
+               ("rhs_min",) <$> (args !? #rhs_min :: Maybe t),
+               ("rhs_max",) <$> (args !? #rhs_max :: Maybe t)]
+      in
+      apply "_contrib_quantized_elemwise_add" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_quantized_flatten" t =
+     '[ '("data", AttrOpt t), '("min_data", AttrOpt t),
+        '("max_data", AttrOpt t)]
+
+__contrib_quantized_flatten ::
+                            forall a t .
+                              (TensorOp t t, Fullfilled "__contrib_quantized_flatten" t a,
+                               HasCallStack) =>
+                              ArgsHMap "__contrib_quantized_flatten" t a -> TensorApply t
+__contrib_quantized_flatten args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("min_data",) <$> (args !? #min_data :: Maybe t),
+               ("max_data",) <$> (args !? #max_data :: Maybe t)]
+      in
+      apply "_contrib_quantized_flatten" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_quantized_fully_connected" t
+     =
+     '[ '("num_hidden", AttrReq Int), '("no_bias", AttrOpt Bool),
+        '("flatten", AttrOpt Bool), '("data", AttrOpt t),
+        '("weight", AttrOpt t), '("bias", AttrOpt t),
+        '("min_data", AttrOpt t), '("max_data", AttrOpt t),
+        '("min_weight", AttrOpt t), '("max_weight", AttrOpt t),
+        '("min_bias", AttrOpt t), '("max_bias", AttrOpt t)]
+
+__contrib_quantized_fully_connected ::
+                                    forall a t .
+                                      (TensorOp t t,
+                                       Fullfilled "__contrib_quantized_fully_connected" t a,
+                                       HasCallStack) =>
+                                      ArgsHMap "__contrib_quantized_fully_connected" t a ->
+                                        TensorApply t
+__contrib_quantized_fully_connected args
+  = let scalarArgs
+          = catMaybes
+              [("num_hidden",) . showValue <$>
+                 (args !? #num_hidden :: Maybe Int),
+               ("no_bias",) . showValue <$> (args !? #no_bias :: Maybe Bool),
+               ("flatten",) . showValue <$> (args !? #flatten :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("weight",) <$> (args !? #weight :: Maybe t),
+               ("bias",) <$> (args !? #bias :: Maybe t),
+               ("min_data",) <$> (args !? #min_data :: Maybe t),
+               ("max_data",) <$> (args !? #max_data :: Maybe t),
+               ("min_weight",) <$> (args !? #min_weight :: Maybe t),
+               ("max_weight",) <$> (args !? #max_weight :: Maybe t),
+               ("min_bias",) <$> (args !? #min_bias :: Maybe t),
+               ("max_bias",) <$> (args !? #max_bias :: Maybe t)]
+      in
+      apply "_contrib_quantized_fully_connected" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_quantized_pooling" t =
+     '[ '("kernel", AttrOpt [Int]),
+        '("pool_type", AttrOpt (EnumType '["avg", "lp", "max", "sum"])),
+        '("global_pool", AttrOpt Bool), '("cudnn_off", AttrOpt Bool),
+        '("pooling_convention",
+          AttrOpt (EnumType '["full", "same", "valid"])),
+        '("stride", AttrOpt [Int]), '("pad", AttrOpt [Int]),
+        '("p_value", AttrOpt (Maybe Int)),
+        '("count_include_pad", AttrOpt (Maybe Bool)),
+        '("layout",
+          AttrOpt
+            (Maybe
+               (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"]))),
+        '("data", AttrOpt t), '("min_data", AttrOpt t),
+        '("max_data", AttrOpt t)]
+
+__contrib_quantized_pooling ::
+                            forall a t .
+                              (TensorOp t t, Fullfilled "__contrib_quantized_pooling" t a,
+                               HasCallStack) =>
+                              ArgsHMap "__contrib_quantized_pooling" t a -> TensorApply t
+__contrib_quantized_pooling args
+  = let scalarArgs
+          = catMaybes
+              [("kernel",) . showValue <$> (args !? #kernel :: Maybe [Int]),
+               ("pool_type",) . showValue <$>
+                 (args !? #pool_type ::
+                    Maybe (EnumType '["avg", "lp", "max", "sum"])),
+               ("global_pool",) . showValue <$>
+                 (args !? #global_pool :: Maybe Bool),
+               ("cudnn_off",) . showValue <$> (args !? #cudnn_off :: Maybe Bool),
+               ("pooling_convention",) . showValue <$>
+                 (args !? #pooling_convention ::
+                    Maybe (EnumType '["full", "same", "valid"])),
+               ("stride",) . showValue <$> (args !? #stride :: Maybe [Int]),
+               ("pad",) . showValue <$> (args !? #pad :: Maybe [Int]),
+               ("p_value",) . showValue <$>
+                 (args !? #p_value :: Maybe (Maybe Int)),
+               ("count_include_pad",) . showValue <$>
+                 (args !? #count_include_pad :: Maybe (Maybe Bool)),
+               ("layout",) . showValue <$>
+                 (args !? #layout ::
+                    Maybe
+                      (Maybe
+                         (EnumType '["NCDHW", "NCHW", "NCW", "NDHWC", "NHWC", "NWC"])))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("min_data",) <$> (args !? #min_data :: Maybe t),
+               ("max_data",) <$> (args !? #max_data :: Maybe t)]
+      in
+      apply "_contrib_quantized_pooling" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_requantize" t =
+     '[ '("out_type", AttrOpt (EnumType '["auto", "int8", "uint8"])),
+        '("min_calib_range", AttrOpt (Maybe Float)),
+        '("max_calib_range", AttrOpt (Maybe Float)), '("data", AttrOpt t),
+        '("min_range", AttrOpt t), '("max_range", AttrOpt t)]
+
+__contrib_requantize ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__contrib_requantize" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__contrib_requantize" t a -> TensorApply t
+__contrib_requantize args
+  = let scalarArgs
+          = catMaybes
+              [("out_type",) . showValue <$>
+                 (args !? #out_type :: Maybe (EnumType '["auto", "int8", "uint8"])),
+               ("min_calib_range",) . showValue <$>
+                 (args !? #min_calib_range :: Maybe (Maybe Float)),
+               ("max_calib_range",) . showValue <$>
+                 (args !? #max_calib_range :: Maybe (Maybe Float))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("min_range",) <$> (args !? #min_range :: Maybe t),
+               ("max_range",) <$> (args !? #max_range :: Maybe t)]
+      in
+      apply "_contrib_requantize" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_round_ste" t =
+     '[ '("data", AttrOpt t)]
+
+__contrib_round_ste ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__contrib_round_ste" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__contrib_round_ste" t a -> TensorApply t
+__contrib_round_ste args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_round_ste" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__contrib_sign_ste" t =
+     '[ '("data", AttrOpt t)]
+
+__contrib_sign_ste ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__contrib_sign_ste" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__contrib_sign_ste" t a -> TensorApply t
+__contrib_sign_ste args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_contrib_sign_ste" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__copy" t = '[ '("data", AttrOpt t)]
+
+__copy ::
+       forall a t .
+         (TensorOp t t, Fullfilled "__copy" t a, HasCallStack) =>
+         ArgsHMap "__copy" t a -> TensorApply t
+__copy args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "_copy" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__copyto" t = '[ '("data", AttrOpt t)]
+
+__copyto ::
+         forall a t .
+           (TensorOp t t, Fullfilled "__copyto" t a, HasCallStack) =>
+           ArgsHMap "__copyto" t a -> TensorApply t
+__copyto args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "_copyto" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__cvcopyMakeBorder" t =
+     '[ '("top", AttrReq Int), '("bot", AttrReq Int),
+        '("left", AttrReq Int), '("right", AttrReq Int),
+        '("type", AttrOpt Int), '("value", AttrOpt Double),
+        '("values", AttrOpt [Double]), '("src", AttrOpt t)]
+
+__cvcopyMakeBorder ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__cvcopyMakeBorder" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__cvcopyMakeBorder" t a -> TensorApply t
+__cvcopyMakeBorder args
+  = let scalarArgs
+          = catMaybes
+              [("top",) . showValue <$> (args !? #top :: Maybe Int),
+               ("bot",) . showValue <$> (args !? #bot :: Maybe Int),
+               ("left",) . showValue <$> (args !? #left :: Maybe Int),
+               ("right",) . showValue <$> (args !? #right :: Maybe Int),
+               ("type",) . showValue <$> (args !? #type :: Maybe Int),
+               ("value",) . showValue <$> (args !? #value :: Maybe Double),
+               ("values",) . showValue <$> (args !? #values :: Maybe [Double])]
+        tensorKeyArgs = catMaybes [("src",) <$> (args !? #src :: Maybe t)]
+      in
+      apply "_cvcopyMakeBorder" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__cvimdecode" t =
+     '[ '("flag", AttrOpt Int), '("to_rgb", AttrOpt Bool),
+        '("buf", AttrOpt t)]
+
+__cvimdecode ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__cvimdecode" t a, HasCallStack) =>
+               ArgsHMap "__cvimdecode" t a -> TensorApply t
+__cvimdecode args
+  = let scalarArgs
+          = catMaybes
+              [("flag",) . showValue <$> (args !? #flag :: Maybe Int),
+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
+        tensorKeyArgs = catMaybes [("buf",) <$> (args !? #buf :: Maybe t)]
+      in
+      apply "_cvimdecode" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__cvimread" t =
+     '[ '("filename", AttrReq Text), '("flag", AttrOpt Int),
+        '("to_rgb", AttrOpt Bool)]
+
+__cvimread ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__cvimread" t a, HasCallStack) =>
+             ArgsHMap "__cvimread" t a -> TensorApply t
+__cvimread args
+  = let scalarArgs
+          = catMaybes
+              [("filename",) . showValue <$> (args !? #filename :: Maybe Text),
+               ("flag",) . showValue <$> (args !? #flag :: Maybe Int),
+               ("to_rgb",) . showValue <$> (args !? #to_rgb :: Maybe Bool)]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_cvimread" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__cvimresize" t =
+     '[ '("w", AttrReq Int), '("h", AttrReq Int),
+        '("interp", AttrOpt Int), '("src", AttrOpt t)]
+
+__cvimresize ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__cvimresize" t a, HasCallStack) =>
+               ArgsHMap "__cvimresize" t a -> TensorApply t
+__cvimresize args
+  = let scalarArgs
+          = catMaybes
+              [("w",) . showValue <$> (args !? #w :: Maybe Int),
+               ("h",) . showValue <$> (args !? #h :: Maybe Int),
+               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]
+        tensorKeyArgs = catMaybes [("src",) <$> (args !? #src :: Maybe t)]
+      in
+      apply "_cvimresize" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__div_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__div_scalar ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__div_scalar" t a, HasCallStack) =>
+               ArgsHMap "__div_scalar" t a -> TensorApply t
+__div_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_div_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__equal" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__equal ::
+        forall a t .
+          (TensorOp t t, Fullfilled "__equal" t a, HasCallStack) =>
+          ArgsHMap "__equal" t a -> TensorApply t
+__equal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in apply "_equal" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__equal_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__equal_scalar ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__equal_scalar" t a, HasCallStack) =>
+                 ArgsHMap "__equal_scalar" t a -> TensorApply t
+__equal_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_equal_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__full" t =
+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "int8",
+                 "uint8"])),
+        '("value", AttrReq Double)]
+
+__full ::
+       forall a t .
+         (TensorOp t t, Fullfilled "__full" t a, HasCallStack) =>
+         ArgsHMap "__full" t a -> TensorApply t
+__full args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "int8",
+                           "uint8"])),
+               ("value",) . showValue <$> (args !? #value :: Maybe Double)]
+        tensorKeyArgs = catMaybes []
+      in apply "_full" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__grad_add" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__grad_add ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__grad_add" t a, HasCallStack) =>
+             ArgsHMap "__grad_add" t a -> TensorApply t
+__grad_add args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_grad_add" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__greater" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__greater ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__greater" t a, HasCallStack) =>
+            ArgsHMap "__greater" t a -> TensorApply t
+__greater args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_greater" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__greater_equal" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__greater_equal ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__greater_equal" t a, HasCallStack) =>
+                  ArgsHMap "__greater_equal" t a -> TensorApply t
+__greater_equal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_greater_equal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__greater_equal_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__greater_equal_scalar ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__greater_equal_scalar" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__greater_equal_scalar" t a -> TensorApply t
+__greater_equal_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_greater_equal_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__greater_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__greater_scalar ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__greater_scalar" t a, HasCallStack) =>
+                   ArgsHMap "__greater_scalar" t a -> TensorApply t
+__greater_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_greater_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__histogram" t =
+     '[ '("bin_cnt", AttrOpt (Maybe Int)), '("range", AttrOpt Int),
+        '("data", AttrOpt t), '("bins", AttrOpt t)]
+
+__histogram ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__histogram" t a, HasCallStack) =>
+              ArgsHMap "__histogram" t a -> TensorApply t
+__histogram args
+  = let scalarArgs
+          = catMaybes
+              [("bin_cnt",) . showValue <$>
+                 (args !? #bin_cnt :: Maybe (Maybe Int)),
+               ("range",) . showValue <$> (args !? #range :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("bins",) <$> (args !? #bins :: Maybe t)]
+      in
+      apply "_histogram" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__hypot" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__hypot ::
+        forall a t .
+          (TensorOp t t, Fullfilled "__hypot" t a, HasCallStack) =>
+          ArgsHMap "__hypot" t a -> TensorApply t
+__hypot args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in apply "_hypot" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__hypot_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__hypot_scalar ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__hypot_scalar" t a, HasCallStack) =>
+                 ArgsHMap "__hypot_scalar" t a -> TensorApply t
+__hypot_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_hypot_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__identity_with_attr_like_rhs" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__identity_with_attr_like_rhs ::
+                              forall a t .
+                                (TensorOp t t, Fullfilled "__identity_with_attr_like_rhs" t a,
+                                 HasCallStack) =>
+                                ArgsHMap "__identity_with_attr_like_rhs" t a -> TensorApply t
+__identity_with_attr_like_rhs args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_identity_with_attr_like_rhs" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_adjust_lighting" t =
+     '[ '("alpha", AttrReq [Float]), '("data", AttrOpt t)]
+
+__image_adjust_lighting ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__image_adjust_lighting" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__image_adjust_lighting" t a -> TensorApply t
+__image_adjust_lighting args
+  = let scalarArgs
+          = catMaybes
+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe [Float])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_adjust_lighting" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_crop" t =
+     '[ '("x", AttrReq Int), '("y", AttrReq Int),
+        '("width", AttrReq Int), '("height", AttrReq Int),
+        '("data", AttrOpt t)]
+
+__image_crop ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__image_crop" t a, HasCallStack) =>
+               ArgsHMap "__image_crop" t a -> TensorApply t
+__image_crop args
+  = let scalarArgs
+          = catMaybes
+              [("x",) . showValue <$> (args !? #x :: Maybe Int),
+               ("y",) . showValue <$> (args !? #y :: Maybe Int),
+               ("width",) . showValue <$> (args !? #width :: Maybe Int),
+               ("height",) . showValue <$> (args !? #height :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_crop" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_flip_left_right" t =
+     '[ '("data", AttrOpt t)]
+
+__image_flip_left_right ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__image_flip_left_right" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__image_flip_left_right" t a -> TensorApply t
+__image_flip_left_right args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_flip_left_right" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_flip_top_bottom" t =
+     '[ '("data", AttrOpt t)]
+
+__image_flip_top_bottom ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__image_flip_top_bottom" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__image_flip_top_bottom" t a -> TensorApply t
+__image_flip_top_bottom args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_flip_top_bottom" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_normalize" t =
+     '[ '("mean", AttrOpt [Float]), '("std", AttrOpt [Float]),
+        '("data", AttrOpt t)]
+
+__image_normalize ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__image_normalize" t a, HasCallStack) =>
+                    ArgsHMap "__image_normalize" t a -> TensorApply t
+__image_normalize args
+  = let scalarArgs
+          = catMaybes
+              [("mean",) . showValue <$> (args !? #mean :: Maybe [Float]),
+               ("std",) . showValue <$> (args !? #std :: Maybe [Float])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_normalize" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_random_brightness" t =
+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
+        '("data", AttrOpt t)]
+
+__image_random_brightness ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "__image_random_brightness" t a,
+                             HasCallStack) =>
+                            ArgsHMap "__image_random_brightness" t a -> TensorApply t
+__image_random_brightness args
+  = let scalarArgs
+          = catMaybes
+              [("min_factor",) . showValue <$>
+                 (args !? #min_factor :: Maybe Float),
+               ("max_factor",) . showValue <$>
+                 (args !? #max_factor :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_random_brightness" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_random_color_jitter" t =
+     '[ '("brightness", AttrReq Float), '("contrast", AttrReq Float),
+        '("saturation", AttrReq Float), '("hue", AttrReq Float),
+        '("data", AttrOpt t)]
+
+__image_random_color_jitter ::
+                            forall a t .
+                              (TensorOp t t, Fullfilled "__image_random_color_jitter" t a,
+                               HasCallStack) =>
+                              ArgsHMap "__image_random_color_jitter" t a -> TensorApply t
+__image_random_color_jitter args
+  = let scalarArgs
+          = catMaybes
+              [("brightness",) . showValue <$>
+                 (args !? #brightness :: Maybe Float),
+               ("contrast",) . showValue <$> (args !? #contrast :: Maybe Float),
+               ("saturation",) . showValue <$>
+                 (args !? #saturation :: Maybe Float),
+               ("hue",) . showValue <$> (args !? #hue :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_random_color_jitter" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_random_contrast" t =
+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
+        '("data", AttrOpt t)]
+
+__image_random_contrast ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__image_random_contrast" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__image_random_contrast" t a -> TensorApply t
+__image_random_contrast args
+  = let scalarArgs
+          = catMaybes
+              [("min_factor",) . showValue <$>
+                 (args !? #min_factor :: Maybe Float),
+               ("max_factor",) . showValue <$>
+                 (args !? #max_factor :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_random_contrast" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_random_flip_left_right" t =
+     '[ '("data", AttrOpt t)]
+
+__image_random_flip_left_right ::
+                               forall a t .
+                                 (TensorOp t t, Fullfilled "__image_random_flip_left_right" t a,
+                                  HasCallStack) =>
+                                 ArgsHMap "__image_random_flip_left_right" t a -> TensorApply t
+__image_random_flip_left_right args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_random_flip_left_right" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_random_flip_top_bottom" t =
+     '[ '("data", AttrOpt t)]
+
+__image_random_flip_top_bottom ::
+                               forall a t .
+                                 (TensorOp t t, Fullfilled "__image_random_flip_top_bottom" t a,
+                                  HasCallStack) =>
+                                 ArgsHMap "__image_random_flip_top_bottom" t a -> TensorApply t
+__image_random_flip_top_bottom args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_random_flip_top_bottom" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_random_hue" t =
+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
+        '("data", AttrOpt t)]
+
+__image_random_hue ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__image_random_hue" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__image_random_hue" t a -> TensorApply t
+__image_random_hue args
+  = let scalarArgs
+          = catMaybes
+              [("min_factor",) . showValue <$>
+                 (args !? #min_factor :: Maybe Float),
+               ("max_factor",) . showValue <$>
+                 (args !? #max_factor :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_random_hue" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_random_lighting" t =
+     '[ '("alpha_std", AttrOpt Float), '("data", AttrOpt t)]
+
+__image_random_lighting ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__image_random_lighting" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__image_random_lighting" t a -> TensorApply t
+__image_random_lighting args
+  = let scalarArgs
+          = catMaybes
+              [("alpha_std",) . showValue <$>
+                 (args !? #alpha_std :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_random_lighting" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_random_saturation" t =
+     '[ '("min_factor", AttrReq Float), '("max_factor", AttrReq Float),
+        '("data", AttrOpt t)]
+
+__image_random_saturation ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "__image_random_saturation" t a,
+                             HasCallStack) =>
+                            ArgsHMap "__image_random_saturation" t a -> TensorApply t
+__image_random_saturation args
+  = let scalarArgs
+          = catMaybes
+              [("min_factor",) . showValue <$>
+                 (args !? #min_factor :: Maybe Float),
+               ("max_factor",) . showValue <$>
+                 (args !? #max_factor :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_random_saturation" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_resize" t =
+     '[ '("size", AttrOpt [Int]), '("keep_ratio", AttrOpt Bool),
+        '("interp", AttrOpt Int), '("data", AttrOpt t)]
+
+__image_resize ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__image_resize" t a, HasCallStack) =>
+                 ArgsHMap "__image_resize" t a -> TensorApply t
+__image_resize args
+  = let scalarArgs
+          = catMaybes
+              [("size",) . showValue <$> (args !? #size :: Maybe [Int]),
+               ("keep_ratio",) . showValue <$>
+                 (args !? #keep_ratio :: Maybe Bool),
+               ("interp",) . showValue <$> (args !? #interp :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_resize" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__image_to_tensor" t =
+     '[ '("data", AttrOpt t)]
+
+__image_to_tensor ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__image_to_tensor" t a, HasCallStack) =>
+                    ArgsHMap "__image_to_tensor" t a -> TensorApply t
+__image_to_tensor args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_image_to_tensor" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__imdecode" t =
+     '[ '("index", AttrOpt Int), '("x0", AttrOpt Int),
+        '("y0", AttrOpt Int), '("x1", AttrOpt Int), '("y1", AttrOpt Int),
+        '("c", AttrOpt Int), '("size", AttrOpt Int), '("mean", AttrOpt t)]
+
+__imdecode ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__imdecode" t a, HasCallStack) =>
+             ArgsHMap "__imdecode" t a -> TensorApply t
+__imdecode args
+  = let scalarArgs
+          = catMaybes
+              [("index",) . showValue <$> (args !? #index :: Maybe Int),
+               ("x0",) . showValue <$> (args !? #x0 :: Maybe Int),
+               ("y0",) . showValue <$> (args !? #y0 :: Maybe Int),
+               ("x1",) . showValue <$> (args !? #x1 :: Maybe Int),
+               ("y1",) . showValue <$> (args !? #y1 :: Maybe Int),
+               ("c",) . showValue <$> (args !? #c :: Maybe Int),
+               ("size",) . showValue <$> (args !? #size :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("mean",) <$> (args !? #mean :: Maybe t)]
+      in
+      apply "_imdecode" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__lesser" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__lesser ::
+         forall a t .
+           (TensorOp t t, Fullfilled "__lesser" t a, HasCallStack) =>
+           ArgsHMap "__lesser" t a -> TensorApply t
+__lesser args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in apply "_lesser" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__lesser_equal" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__lesser_equal ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__lesser_equal" t a, HasCallStack) =>
+                 ArgsHMap "__lesser_equal" t a -> TensorApply t
+__lesser_equal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_lesser_equal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__lesser_equal_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__lesser_equal_scalar ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__lesser_equal_scalar" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__lesser_equal_scalar" t a -> TensorApply t
+__lesser_equal_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_lesser_equal_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__lesser_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__lesser_scalar ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__lesser_scalar" t a, HasCallStack) =>
+                  ArgsHMap "__lesser_scalar" t a -> TensorApply t
+__lesser_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_lesser_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_det" t =
+     '[ '("a", AttrOpt t)]
+
+__linalg_det ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__linalg_det" t a, HasCallStack) =>
+               ArgsHMap "__linalg_det" t a -> TensorApply t
+__linalg_det args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_linalg_det" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_extractdiag" t =
+     '[ '("offset", AttrOpt Int), '("a", AttrOpt t)]
+
+__linalg_extractdiag ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__linalg_extractdiag" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__linalg_extractdiag" t a -> TensorApply t
+__linalg_extractdiag args
+  = let scalarArgs
+          = catMaybes
+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int)]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_linalg_extractdiag" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_extracttrian" t =
+     '[ '("offset", AttrOpt Int), '("lower", AttrOpt Bool),
+        '("a", AttrOpt t)]
+
+__linalg_extracttrian ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__linalg_extracttrian" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__linalg_extracttrian" t a -> TensorApply t
+__linalg_extracttrian args
+  = let scalarArgs
+          = catMaybes
+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),
+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_linalg_extracttrian" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_gelqf" t =
+     '[ '("a", AttrOpt t)]
+
+__linalg_gelqf ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__linalg_gelqf" t a, HasCallStack) =>
+                 ArgsHMap "__linalg_gelqf" t a -> TensorApply t
+__linalg_gelqf args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_linalg_gelqf" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_gemm" t =
+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
+        '("alpha", AttrOpt Double), '("beta", AttrOpt Double),
+        '("axis", AttrOpt Int), '("a", AttrOpt t), '("b", AttrOpt t),
+        '("c", AttrOpt t)]
+
+__linalg_gemm ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__linalg_gemm" t a, HasCallStack) =>
+                ArgsHMap "__linalg_gemm" t a -> TensorApply t
+__linalg_gemm args
+  = let scalarArgs
+          = catMaybes
+              [("transpose_a",) . showValue <$>
+                 (args !? #transpose_a :: Maybe Bool),
+               ("transpose_b",) . showValue <$>
+                 (args !? #transpose_b :: Maybe Bool),
+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
+               ("beta",) . showValue <$> (args !? #beta :: Maybe Double),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("a",) <$> (args !? #a :: Maybe t),
+               ("b",) <$> (args !? #b :: Maybe t),
+               ("c",) <$> (args !? #c :: Maybe t)]
+      in
+      apply "_linalg_gemm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_gemm2" t =
+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
+        '("alpha", AttrOpt Double), '("axis", AttrOpt Int),
+        '("a", AttrOpt t), '("b", AttrOpt t)]
+
+__linalg_gemm2 ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__linalg_gemm2" t a, HasCallStack) =>
+                 ArgsHMap "__linalg_gemm2" t a -> TensorApply t
+__linalg_gemm2 args
+  = let scalarArgs
+          = catMaybes
+              [("transpose_a",) . showValue <$>
+                 (args !? #transpose_a :: Maybe Bool),
+               ("transpose_b",) . showValue <$>
+                 (args !? #transpose_b :: Maybe Bool),
+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("a",) <$> (args !? #a :: Maybe t),
+               ("b",) <$> (args !? #b :: Maybe t)]
+      in
+      apply "_linalg_gemm2" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_inverse" t =
+     '[ '("a", AttrOpt t)]
+
+__linalg_inverse ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__linalg_inverse" t a, HasCallStack) =>
+                   ArgsHMap "__linalg_inverse" t a -> TensorApply t
+__linalg_inverse args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_linalg_inverse" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_makediag" t =
+     '[ '("offset", AttrOpt Int), '("a", AttrOpt t)]
+
+__linalg_makediag ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__linalg_makediag" t a, HasCallStack) =>
+                    ArgsHMap "__linalg_makediag" t a -> TensorApply t
+__linalg_makediag args
+  = let scalarArgs
+          = catMaybes
+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int)]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_linalg_makediag" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_maketrian" t =
+     '[ '("offset", AttrOpt Int), '("lower", AttrOpt Bool),
+        '("a", AttrOpt t)]
+
+__linalg_maketrian ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__linalg_maketrian" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__linalg_maketrian" t a -> TensorApply t
+__linalg_maketrian args
+  = let scalarArgs
+          = catMaybes
+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),
+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool)]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_linalg_maketrian" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_potrf" t =
+     '[ '("a", AttrOpt t)]
+
+__linalg_potrf ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__linalg_potrf" t a, HasCallStack) =>
+                 ArgsHMap "__linalg_potrf" t a -> TensorApply t
+__linalg_potrf args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_linalg_potrf" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_potri" t =
+     '[ '("a", AttrOpt t)]
+
+__linalg_potri ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__linalg_potri" t a, HasCallStack) =>
+                 ArgsHMap "__linalg_potri" t a -> TensorApply t
+__linalg_potri args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_linalg_potri" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_slogdet" t =
+     '[ '("a", AttrOpt t)]
+
+__linalg_slogdet ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__linalg_slogdet" t a, HasCallStack) =>
+                   ArgsHMap "__linalg_slogdet" t a -> TensorApply t
+__linalg_slogdet args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_linalg_slogdet" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_sumlogdiag" t =
+     '[ '("a", AttrOpt t)]
+
+__linalg_sumlogdiag ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__linalg_sumlogdiag" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__linalg_sumlogdiag" t a -> TensorApply t
+__linalg_sumlogdiag args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_linalg_sumlogdiag" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_syevd" t =
+     '[ '("a", AttrOpt t)]
+
+__linalg_syevd ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__linalg_syevd" t a, HasCallStack) =>
+                 ArgsHMap "__linalg_syevd" t a -> TensorApply t
+__linalg_syevd args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_linalg_syevd" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_syrk" t =
+     '[ '("transpose", AttrOpt Bool), '("alpha", AttrOpt Double),
+        '("a", AttrOpt t)]
+
+__linalg_syrk ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__linalg_syrk" t a, HasCallStack) =>
+                ArgsHMap "__linalg_syrk" t a -> TensorApply t
+__linalg_syrk args
+  = let scalarArgs
+          = catMaybes
+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_linalg_syrk" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_trmm" t =
+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
+        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),
+        '("a", AttrOpt t), '("b", AttrOpt t)]
+
+__linalg_trmm ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__linalg_trmm" t a, HasCallStack) =>
+                ArgsHMap "__linalg_trmm" t a -> TensorApply t
+__linalg_trmm args
+  = let scalarArgs
+          = catMaybes
+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),
+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
+        tensorKeyArgs
+          = catMaybes
+              [("a",) <$> (args !? #a :: Maybe t),
+               ("b",) <$> (args !? #b :: Maybe t)]
+      in
+      apply "_linalg_trmm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linalg_trsm" t =
+     '[ '("transpose", AttrOpt Bool), '("rightside", AttrOpt Bool),
+        '("lower", AttrOpt Bool), '("alpha", AttrOpt Double),
+        '("a", AttrOpt t), '("b", AttrOpt t)]
+
+__linalg_trsm ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__linalg_trsm" t a, HasCallStack) =>
+                ArgsHMap "__linalg_trsm" t a -> TensorApply t
+__linalg_trsm args
+  = let scalarArgs
+          = catMaybes
+              [("transpose",) . showValue <$> (args !? #transpose :: Maybe Bool),
+               ("rightside",) . showValue <$> (args !? #rightside :: Maybe Bool),
+               ("lower",) . showValue <$> (args !? #lower :: Maybe Bool),
+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Double)]
+        tensorKeyArgs
+          = catMaybes
+              [("a",) <$> (args !? #a :: Maybe t),
+               ("b",) <$> (args !? #b :: Maybe t)]
+      in
+      apply "_linalg_trsm" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__linspace" t =
+     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),
+        '("step", AttrOpt Double), '("repeat", AttrOpt Int),
+        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "int8",
+                 "uint8"]))]
+
+__linspace ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__linspace" t a, HasCallStack) =>
+             ArgsHMap "__linspace" t a -> TensorApply t
+__linspace args
+  = let scalarArgs
+          = catMaybes
+              [("start",) . showValue <$> (args !? #start :: Maybe Double),
+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
+               ("step",) . showValue <$> (args !? #step :: Maybe Double),
+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
+               ("infer_range",) . showValue <$>
+                 (args !? #infer_range :: Maybe Bool),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "int8",
+                           "uint8"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_linspace" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__logical_and" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__logical_and ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__logical_and" t a, HasCallStack) =>
+                ArgsHMap "__logical_and" t a -> TensorApply t
+__logical_and args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_logical_and" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__logical_and_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__logical_and_scalar ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__logical_and_scalar" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__logical_and_scalar" t a -> TensorApply t
+__logical_and_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_logical_and_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__logical_or" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__logical_or ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__logical_or" t a, HasCallStack) =>
+               ArgsHMap "__logical_or" t a -> TensorApply t
+__logical_or args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_logical_or" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__logical_or_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__logical_or_scalar ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__logical_or_scalar" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__logical_or_scalar" t a -> TensorApply t
+__logical_or_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_logical_or_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__logical_xor" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__logical_xor ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__logical_xor" t a, HasCallStack) =>
+                ArgsHMap "__logical_xor" t a -> TensorApply t
+__logical_xor args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_logical_xor" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__logical_xor_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__logical_xor_scalar ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__logical_xor_scalar" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__logical_xor_scalar" t a -> TensorApply t
+__logical_xor_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_logical_xor_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__maximum" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__maximum ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__maximum" t a, HasCallStack) =>
+            ArgsHMap "__maximum" t a -> TensorApply t
+__maximum args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_maximum" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__maximum_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__maximum_scalar ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__maximum_scalar" t a, HasCallStack) =>
+                   ArgsHMap "__maximum_scalar" t a -> TensorApply t
+__maximum_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_maximum_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__minimum" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__minimum ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__minimum" t a, HasCallStack) =>
+            ArgsHMap "__minimum" t a -> TensorApply t
+__minimum args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_minimum" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__minimum_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__minimum_scalar ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__minimum_scalar" t a, HasCallStack) =>
+                   ArgsHMap "__minimum_scalar" t a -> TensorApply t
+__minimum_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_minimum_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__minus_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__minus_scalar ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__minus_scalar" t a, HasCallStack) =>
+                 ArgsHMap "__minus_scalar" t a -> TensorApply t
+__minus_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_minus_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__mod" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__mod ::
+      forall a t .
+        (TensorOp t t, Fullfilled "__mod" t a, HasCallStack) =>
+        ArgsHMap "__mod" t a -> TensorApply t
+__mod args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in apply "_mod" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__mod_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__mod_scalar ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__mod_scalar" t a, HasCallStack) =>
+               ArgsHMap "__mod_scalar" t a -> TensorApply t
+__mod_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_mod_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__mp_adamw_update" t =
+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
+        '("wd", AttrOpt Float), '("eta", AttrReq Float),
+        '("clip_gradient", AttrOpt Float), '("weight", AttrOpt t),
+        '("grad", AttrOpt t), '("mean", AttrOpt t), '("var", AttrOpt t),
+        '("weight32", AttrOpt t), '("rescale_grad", AttrOpt t)]
+
+__mp_adamw_update ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__mp_adamw_update" t a, HasCallStack) =>
+                    ArgsHMap "__mp_adamw_update" t a -> TensorApply t
+__mp_adamw_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("eta",) . showValue <$> (args !? #eta :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("mean",) <$> (args !? #mean :: Maybe t),
+               ("var",) <$> (args !? #var :: Maybe t),
+               ("weight32",) <$> (args !? #weight32 :: Maybe t),
+               ("rescale_grad",) <$> (args !? #rescale_grad :: Maybe t)]
+      in
+      apply "_mp_adamw_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__mul_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__mul_scalar ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__mul_scalar" t a, HasCallStack) =>
+               ArgsHMap "__mul_scalar" t a -> TensorApply t
+__mul_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_mul_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__multi_adamw_update" t =
+     '[ '("lrs", AttrReq [Float]), '("beta1", AttrOpt Float),
+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
+        '("wds", AttrReq [Float]), '("etas", AttrReq [Float]),
+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+__multi_adamw_update ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__multi_adamw_update" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__multi_adamw_update" t a -> TensorApply t
+__multi_adamw_update args
+  = let scalarArgs
+          = catMaybes
+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
+               ("etas",) . showValue <$> (args !? #etas :: Maybe [Float]),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("num_weights",) . showValue <$>
+                 (args !? #num_weights :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "_multi_adamw_update" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__multi_mp_adamw_update" t =
+     '[ '("lrs", AttrReq [Float]), '("beta1", AttrOpt Float),
+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
+        '("wds", AttrReq [Float]), '("etas", AttrReq [Float]),
+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+__multi_mp_adamw_update ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__multi_mp_adamw_update" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__multi_mp_adamw_update" t a -> TensorApply t
+__multi_mp_adamw_update args
+  = let scalarArgs
+          = catMaybes
+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
+               ("etas",) . showValue <$> (args !? #etas :: Maybe [Float]),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("num_weights",) . showValue <$>
+                 (args !? #num_weights :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "_multi_mp_adamw_update" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__not_equal" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__not_equal ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__not_equal" t a, HasCallStack) =>
+              ArgsHMap "__not_equal" t a -> TensorApply t
+__not_equal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_not_equal" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__not_equal_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__not_equal_scalar ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__not_equal_scalar" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__not_equal_scalar" t a -> TensorApply t
+__not_equal_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_not_equal_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_broadcast_to" t =
+     '[ '("shape", AttrOpt [Int]), '("array", AttrOpt t)]
+
+__np_broadcast_to ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__np_broadcast_to" t a, HasCallStack) =>
+                    ArgsHMap "__np_broadcast_to" t a -> TensorApply t
+__np_broadcast_to args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes [("array",) <$> (args !? #array :: Maybe t)]
+      in
+      apply "_np_broadcast_to" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_copy" t = '[ '("a", AttrOpt t)]
+
+__np_copy ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__np_copy" t a, HasCallStack) =>
+            ArgsHMap "__np_copy" t a -> TensorApply t
+__np_copy args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_np_copy" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_cumsum" t =
+     '[ '("axis", AttrOpt (Maybe Int)),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["float16", "float32", "float64", "int32", "int64", "int8"]))),
+        '("a", AttrOpt t)]
+
+__np_cumsum ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__np_cumsum" t a, HasCallStack) =>
+              ArgsHMap "__np_cumsum" t a -> TensorApply t
+__np_cumsum args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["float16", "float32", "float64", "int32", "int64", "int8"])))]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_np_cumsum" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_dot" t =
+     '[ '("a", AttrOpt t), '("b", AttrOpt t)]
+
+__np_dot ::
+         forall a t .
+           (TensorOp t t, Fullfilled "__np_dot" t a, HasCallStack) =>
+           ArgsHMap "__np_dot" t a -> TensorApply t
+__np_dot args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("a",) <$> (args !? #a :: Maybe t),
+               ("b",) <$> (args !? #b :: Maybe t)]
+      in apply "_np_dot" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_max" t =
+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
+        '("initial", AttrOpt (Maybe Double)), '("a", AttrOpt t)]
+
+__np_max ::
+         forall a t .
+           (TensorOp t t, Fullfilled "__np_max" t a, HasCallStack) =>
+           ArgsHMap "__np_max" t a -> TensorApply t
+__np_max args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
+               ("initial",) . showValue <$>
+                 (args !? #initial :: Maybe (Maybe Double))]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in apply "_np_max" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_min" t =
+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
+        '("initial", AttrOpt (Maybe Double)), '("a", AttrOpt t)]
+
+__np_min ::
+         forall a t .
+           (TensorOp t t, Fullfilled "__np_min" t a, HasCallStack) =>
+           ArgsHMap "__np_min" t a -> TensorApply t
+__np_min args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
+               ("initial",) . showValue <$>
+                 (args !? #initial :: Maybe (Maybe Double))]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in apply "_np_min" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_moveaxis" t =
+     '[ '("source", AttrReq [Int]), '("destination", AttrReq [Int]),
+        '("a", AttrOpt t)]
+
+__np_moveaxis ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__np_moveaxis" t a, HasCallStack) =>
+                ArgsHMap "__np_moveaxis" t a -> TensorApply t
+__np_moveaxis args
+  = let scalarArgs
+          = catMaybes
+              [("source",) . showValue <$> (args !? #source :: Maybe [Int]),
+               ("destination",) . showValue <$>
+                 (args !? #destination :: Maybe [Int])]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_np_moveaxis" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_ones_like" t =
+     '[ '("a", AttrOpt t)]
+
+__np_ones_like ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__np_ones_like" t a, HasCallStack) =>
+                 ArgsHMap "__np_ones_like" t a -> TensorApply t
+__np_ones_like args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_np_ones_like" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_prod" t =
+     '[ '("axis", AttrOpt (Maybe [Int])),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["bool", "float16", "float32", "float64", "int32", "int64",
+                    "int8"]))),
+        '("keepdims", AttrOpt Bool), '("initial", AttrOpt (Maybe Double)),
+        '("a", AttrOpt t)]
+
+__np_prod ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__np_prod" t a, HasCallStack) =>
+            ArgsHMap "__np_prod" t a -> TensorApply t
+__np_prod args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["bool", "float16", "float32", "float64", "int32", "int64",
+                              "int8"]))),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
+               ("initial",) . showValue <$>
+                 (args !? #initial :: Maybe (Maybe Double))]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_np_prod" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_reshape" t =
+     '[ '("newshape", AttrReq [Int]), '("order", AttrOpt Text),
+        '("a", AttrOpt t)]
+
+__np_reshape ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__np_reshape" t a, HasCallStack) =>
+               ArgsHMap "__np_reshape" t a -> TensorApply t
+__np_reshape args
+  = let scalarArgs
+          = catMaybes
+              [("newshape",) . showValue <$> (args !? #newshape :: Maybe [Int]),
+               ("order",) . showValue <$> (args !? #order :: Maybe Text)]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_np_reshape" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_roll" t =
+     '[ '("shift", AttrOpt (Maybe [Int])),
+        '("axis", AttrOpt (Maybe [Int])), '("data", AttrOpt t)]
+
+__np_roll ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__np_roll" t a, HasCallStack) =>
+            ArgsHMap "__np_roll" t a -> TensorApply t
+__np_roll args
+  = let scalarArgs
+          = catMaybes
+              [("shift",) . showValue <$>
+                 (args !? #shift :: Maybe (Maybe [Int])),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_np_roll" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_squeeze" t =
+     '[ '("axis", AttrOpt (Maybe [Int])), '("a", AttrOpt t)]
+
+__np_squeeze ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__np_squeeze" t a, HasCallStack) =>
+               ArgsHMap "__np_squeeze" t a -> TensorApply t
+__np_squeeze args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_np_squeeze" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_sum" t =
+     '[ '("axis", AttrOpt (Maybe [Int])),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["bool", "float16", "float32", "float64", "int32", "int64",
+                    "int8"]))),
+        '("keepdims", AttrOpt Bool), '("initial", AttrOpt (Maybe Double)),
+        '("a", AttrOpt t)]
+
+__np_sum ::
+         forall a t .
+           (TensorOp t t, Fullfilled "__np_sum" t a, HasCallStack) =>
+           ArgsHMap "__np_sum" t a -> TensorApply t
+__np_sum args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["bool", "float16", "float32", "float64", "int32", "int64",
+                              "int8"]))),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
+               ("initial",) . showValue <$>
+                 (args !? #initial :: Maybe (Maybe Double))]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in apply "_np_sum" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_trace" t =
+     '[ '("offset", AttrOpt Int), '("axis1", AttrOpt Int),
+        '("axis2", AttrOpt Int), '("data", AttrOpt t)]
+
+__np_trace ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__np_trace" t a, HasCallStack) =>
+             ArgsHMap "__np_trace" t a -> TensorApply t
+__np_trace args
+  = let scalarArgs
+          = catMaybes
+              [("offset",) . showValue <$> (args !? #offset :: Maybe Int),
+               ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int),
+               ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_np_trace" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_transpose" t =
+     '[ '("axes", AttrOpt [Int]), '("a", AttrOpt t)]
+
+__np_transpose ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__np_transpose" t a, HasCallStack) =>
+                 ArgsHMap "__np_transpose" t a -> TensorApply t
+__np_transpose args
+  = let scalarArgs
+          = catMaybes
+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_np_transpose" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__np_zeros_like" t =
+     '[ '("a", AttrOpt t)]
+
+__np_zeros_like ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__np_zeros_like" t a, HasCallStack) =>
+                  ArgsHMap "__np_zeros_like" t a -> TensorApply t
+__np_zeros_like args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_np_zeros_like" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_absolute" t =
+     '[ '("x", AttrOpt t)]
+
+__npi_absolute ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__npi_absolute" t a, HasCallStack) =>
+                 ArgsHMap "__npi_absolute" t a -> TensorApply t
+__npi_absolute args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_absolute" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_add" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_add ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__npi_add" t a, HasCallStack) =>
+            ArgsHMap "__npi_add" t a -> TensorApply t
+__npi_add args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_add" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_add_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_add_scalar ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__npi_add_scalar" t a, HasCallStack) =>
+                   ArgsHMap "__npi_add_scalar" t a -> TensorApply t
+__npi_add_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_add_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_arange" t =
+     '[ '("start", AttrReq Double), '("stop", AttrOpt (Maybe Double)),
+        '("step", AttrOpt Double), '("repeat", AttrOpt Int),
+        '("infer_range", AttrOpt Bool), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "int8",
+                 "uint8"]))]
+
+__npi_arange ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_arange" t a, HasCallStack) =>
+               ArgsHMap "__npi_arange" t a -> TensorApply t
+__npi_arange args
+  = let scalarArgs
+          = catMaybes
+              [("start",) . showValue <$> (args !? #start :: Maybe Double),
+               ("stop",) . showValue <$> (args !? #stop :: Maybe (Maybe Double)),
+               ("step",) . showValue <$> (args !? #step :: Maybe Double),
+               ("repeat",) . showValue <$> (args !? #repeat :: Maybe Int),
+               ("infer_range",) . showValue <$>
+                 (args !? #infer_range :: Maybe Bool),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "int8",
+                           "uint8"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_npi_arange" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_arccos" t =
+     '[ '("x", AttrOpt t)]
+
+__npi_arccos ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_arccos" t a, HasCallStack) =>
+               ArgsHMap "__npi_arccos" t a -> TensorApply t
+__npi_arccos args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_arccos" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_arccosh" t =
+     '[ '("x", AttrOpt t)]
+
+__npi_arccosh ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__npi_arccosh" t a, HasCallStack) =>
+                ArgsHMap "__npi_arccosh" t a -> TensorApply t
+__npi_arccosh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_arccosh" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_arcsin" t =
+     '[ '("x", AttrOpt t)]
+
+__npi_arcsin ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_arcsin" t a, HasCallStack) =>
+               ArgsHMap "__npi_arcsin" t a -> TensorApply t
+__npi_arcsin args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_arcsin" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_arcsinh" t =
+     '[ '("x", AttrOpt t)]
+
+__npi_arcsinh ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__npi_arcsinh" t a, HasCallStack) =>
+                ArgsHMap "__npi_arcsinh" t a -> TensorApply t
+__npi_arcsinh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_arcsinh" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_arctan" t =
+     '[ '("x", AttrOpt t)]
+
+__npi_arctan ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_arctan" t a, HasCallStack) =>
+               ArgsHMap "__npi_arctan" t a -> TensorApply t
+__npi_arctan args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_arctan" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_arctan2" t =
+     '[ '("x1", AttrOpt t), '("x2", AttrOpt t)]
+
+__npi_arctan2 ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__npi_arctan2" t a, HasCallStack) =>
+                ArgsHMap "__npi_arctan2" t a -> TensorApply t
+__npi_arctan2 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("x1",) <$> (args !? #x1 :: Maybe t),
+               ("x2",) <$> (args !? #x2 :: Maybe t)]
+      in
+      apply "_npi_arctan2" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_arctan2_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_arctan2_scalar ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__npi_arctan2_scalar" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__npi_arctan2_scalar" t a -> TensorApply t
+__npi_arctan2_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_arctan2_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_arctanh" t =
+     '[ '("x", AttrOpt t)]
+
+__npi_arctanh ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__npi_arctanh" t a, HasCallStack) =>
+                ArgsHMap "__npi_arctanh" t a -> TensorApply t
+__npi_arctanh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_arctanh" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_argmax" t =
+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
+        '("data", AttrOpt t)]
+
+__npi_argmax ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_argmax" t a, HasCallStack) =>
+               ArgsHMap "__npi_argmax" t a -> TensorApply t
+__npi_argmax args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_argmax" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_argmin" t =
+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
+        '("data", AttrOpt t)]
+
+__npi_argmin ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_argmin" t a, HasCallStack) =>
+               ArgsHMap "__npi_argmin" t a -> TensorApply t
+__npi_argmin args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_argmin" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_around" t =
+     '[ '("decimals", AttrOpt Int), '("x", AttrOpt t)]
+
+__npi_around ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_around" t a, HasCallStack) =>
+               ArgsHMap "__npi_around" t a -> TensorApply t
+__npi_around args
+  = let scalarArgs
+          = catMaybes
+              [("decimals",) . showValue <$> (args !? #decimals :: Maybe Int)]
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_around" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_bitwise_xor" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_bitwise_xor ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__npi_bitwise_xor" t a, HasCallStack) =>
+                    ArgsHMap "__npi_bitwise_xor" t a -> TensorApply t
+__npi_bitwise_xor args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_bitwise_xor" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_bitwise_xor_scalar" t =
+     '[ '("scalar", AttrOpt Int), '("data", AttrOpt t)]
+
+__npi_bitwise_xor_scalar ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__npi_bitwise_xor_scalar" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__npi_bitwise_xor_scalar" t a -> TensorApply t
+__npi_bitwise_xor_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_bitwise_xor_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_blackman" t =
+     '[ '("m", AttrOpt Int), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "int8",
+                 "uint8"]))]
+
+__npi_blackman ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__npi_blackman" t a, HasCallStack) =>
+                 ArgsHMap "__npi_blackman" t a -> TensorApply t
+__npi_blackman args
+  = let scalarArgs
+          = catMaybes
+              [("m",) . showValue <$> (args !? #m :: Maybe Int),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "int8",
+                           "uint8"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_npi_blackman" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_boolean_mask_assign_scalar" t =
+     '[ '("value", AttrOpt Float), '("data", AttrOpt t),
+        '("mask", AttrOpt t)]
+
+__npi_boolean_mask_assign_scalar ::
+                                 forall a t .
+                                   (TensorOp t t, Fullfilled "__npi_boolean_mask_assign_scalar" t a,
+                                    HasCallStack) =>
+                                   ArgsHMap "__npi_boolean_mask_assign_scalar" t a -> TensorApply t
+__npi_boolean_mask_assign_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("value",) . showValue <$> (args !? #value :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("mask",) <$> (args !? #mask :: Maybe t)]
+      in
+      apply "_npi_boolean_mask_assign_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_boolean_mask_assign_tensor" t =
+     '[ '("data", AttrOpt t), '("mask", AttrOpt t),
+        '("value", AttrOpt t)]
+
+__npi_boolean_mask_assign_tensor ::
+                                 forall a t .
+                                   (TensorOp t t, Fullfilled "__npi_boolean_mask_assign_tensor" t a,
+                                    HasCallStack) =>
+                                   ArgsHMap "__npi_boolean_mask_assign_tensor" t a -> TensorApply t
+__npi_boolean_mask_assign_tensor args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("mask",) <$> (args !? #mask :: Maybe t),
+               ("value",) <$> (args !? #value :: Maybe t)]
+      in
+      apply "_npi_boolean_mask_assign_tensor" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_cbrt" t = '[ '("x", AttrOpt t)]
+
+__npi_cbrt ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_cbrt" t a, HasCallStack) =>
+             ArgsHMap "__npi_cbrt" t a -> TensorApply t
+__npi_cbrt args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_cbrt" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_ceil" t = '[ '("x", AttrOpt t)]
+
+__npi_ceil ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_ceil" t a, HasCallStack) =>
+             ArgsHMap "__npi_ceil" t a -> TensorApply t
+__npi_ceil args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_ceil" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_choice" t =
+     '[ '("a", AttrReq Int), '("size", AttrReq Int),
+        '("ctx", AttrOpt Text), '("replace", AttrOpt Bool),
+        '("weighted", AttrOpt Bool), '("input1", AttrOpt t),
+        '("input2", AttrOpt t)]
+
+__npi_choice ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_choice" t a, HasCallStack) =>
+               ArgsHMap "__npi_choice" t a -> TensorApply t
+__npi_choice args
+  = let scalarArgs
+          = catMaybes
+              [("a",) . showValue <$> (args !? #a :: Maybe Int),
+               ("size",) . showValue <$> (args !? #size :: Maybe Int),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("replace",) . showValue <$> (args !? #replace :: Maybe Bool),
+               ("weighted",) . showValue <$> (args !? #weighted :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("input1",) <$> (args !? #input1 :: Maybe t),
+               ("input2",) <$> (args !? #input2 :: Maybe t)]
+      in
+      apply "_npi_choice" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_column_stack" t =
+     '[ '("num_args", AttrReq Int), '("data", AttrOpt [t])]
+
+__npi_column_stack ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__npi_column_stack" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__npi_column_stack" t a -> TensorApply t
+__npi_column_stack args
+  = let scalarArgs
+          = catMaybes
+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "_npi_column_stack" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__npi_concatenate" t =
+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+__npi_concatenate ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__npi_concatenate" t a, HasCallStack) =>
+                    ArgsHMap "__npi_concatenate" t a -> TensorApply t
+__npi_concatenate args
+  = let scalarArgs
+          = catMaybes
+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "_npi_concatenate" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__npi_copysign" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_copysign ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__npi_copysign" t a, HasCallStack) =>
+                 ArgsHMap "__npi_copysign" t a -> TensorApply t
+__npi_copysign args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_copysign" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_copysign_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_copysign_scalar ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__npi_copysign_scalar" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__npi_copysign_scalar" t a -> TensorApply t
+__npi_copysign_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_copysign_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_cos" t = '[ '("x", AttrOpt t)]
+
+__npi_cos ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__npi_cos" t a, HasCallStack) =>
+            ArgsHMap "__npi_cos" t a -> TensorApply t
+__npi_cos args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_cos" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_cosh" t = '[ '("x", AttrOpt t)]
+
+__npi_cosh ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_cosh" t a, HasCallStack) =>
+             ArgsHMap "__npi_cosh" t a -> TensorApply t
+__npi_cosh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_cosh" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_degrees" t =
+     '[ '("x", AttrOpt t)]
+
+__npi_degrees ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__npi_degrees" t a, HasCallStack) =>
+                ArgsHMap "__npi_degrees" t a -> TensorApply t
+__npi_degrees args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_degrees" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_diff" t =
+     '[ '("n", AttrOpt Int), '("axis", AttrOpt Int), '("a", AttrOpt t)]
+
+__npi_diff ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_diff" t a, HasCallStack) =>
+             ArgsHMap "__npi_diff" t a -> TensorApply t
+__npi_diff args
+  = let scalarArgs
+          = catMaybes
+              [("n",) . showValue <$> (args !? #n :: Maybe Int),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_npi_diff" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_dstack" t =
+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+__npi_dstack ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_dstack" t a, HasCallStack) =>
+               ArgsHMap "__npi_dstack" t a -> TensorApply t
+__npi_dstack args
+  = let scalarArgs
+          = catMaybes
+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "_npi_dstack" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__npi_einsum" t =
+     '[ '("num_args", AttrReq Int), '("subscripts", AttrOpt Text),
+        '("optimize", AttrOpt Int), '("data", AttrOpt [t])]
+
+__npi_einsum ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_einsum" t a, HasCallStack) =>
+               ArgsHMap "__npi_einsum" t a -> TensorApply t
+__npi_einsum args
+  = let scalarArgs
+          = catMaybes
+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
+               ("subscripts",) . showValue <$>
+                 (args !? #subscripts :: Maybe Text),
+               ("optimize",) . showValue <$> (args !? #optimize :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "_npi_einsum" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__npi_equal" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_equal ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__npi_equal" t a, HasCallStack) =>
+              ArgsHMap "__npi_equal" t a -> TensorApply t
+__npi_equal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_equal" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_equal_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_equal_scalar ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__npi_equal_scalar" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__npi_equal_scalar" t a -> TensorApply t
+__npi_equal_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_equal_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_exp" t = '[ '("x", AttrOpt t)]
+
+__npi_exp ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__npi_exp" t a, HasCallStack) =>
+            ArgsHMap "__npi_exp" t a -> TensorApply t
+__npi_exp args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_exp" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_expm1" t = '[ '("x", AttrOpt t)]
+
+__npi_expm1 ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__npi_expm1" t a, HasCallStack) =>
+              ArgsHMap "__npi_expm1" t a -> TensorApply t
+__npi_expm1 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_expm1" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_fix" t = '[ '("x", AttrOpt t)]
+
+__npi_fix ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__npi_fix" t a, HasCallStack) =>
+            ArgsHMap "__npi_fix" t a -> TensorApply t
+__npi_fix args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_fix" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_flip" t =
+     '[ '("axis", AttrReq [Int]), '("data", AttrOpt t)]
+
+__npi_flip ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_flip" t a, HasCallStack) =>
+             ArgsHMap "__npi_flip" t a -> TensorApply t
+__npi_flip args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_flip" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_floor" t = '[ '("x", AttrOpt t)]
+
+__npi_floor ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__npi_floor" t a, HasCallStack) =>
+              ArgsHMap "__npi_floor" t a -> TensorApply t
+__npi_floor args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_floor" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_greater" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_greater ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__npi_greater" t a, HasCallStack) =>
+                ArgsHMap "__npi_greater" t a -> TensorApply t
+__npi_greater args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_greater" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_greater_equal" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_greater_equal ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__npi_greater_equal" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__npi_greater_equal" t a -> TensorApply t
+__npi_greater_equal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_greater_equal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_greater_equal_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_greater_equal_scalar ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__npi_greater_equal_scalar" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__npi_greater_equal_scalar" t a -> TensorApply t
+__npi_greater_equal_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_greater_equal_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_greater_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_greater_scalar ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__npi_greater_scalar" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__npi_greater_scalar" t a -> TensorApply t
+__npi_greater_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_greater_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_hamming" t =
+     '[ '("m", AttrOpt Int), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "int8",
+                 "uint8"]))]
+
+__npi_hamming ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__npi_hamming" t a, HasCallStack) =>
+                ArgsHMap "__npi_hamming" t a -> TensorApply t
+__npi_hamming args
+  = let scalarArgs
+          = catMaybes
+              [("m",) . showValue <$> (args !? #m :: Maybe Int),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "int8",
+                           "uint8"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_npi_hamming" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_hanning" t =
+     '[ '("m", AttrOpt Int), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "int8",
+                 "uint8"]))]
+
+__npi_hanning ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__npi_hanning" t a, HasCallStack) =>
+                ArgsHMap "__npi_hanning" t a -> TensorApply t
+__npi_hanning args
+  = let scalarArgs
+          = catMaybes
+              [("m",) . showValue <$> (args !? #m :: Maybe Int),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "int8",
+                           "uint8"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_npi_hanning" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_hsplit" t =
+     '[ '("indices", AttrReq [Int]), '("axis", AttrOpt Int),
+        '("squeeze_axis", AttrOpt Bool), '("sections", AttrOpt Int),
+        '("data", AttrOpt t)]
+
+__npi_hsplit ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_hsplit" t a, HasCallStack) =>
+               ArgsHMap "__npi_hsplit" t a -> TensorApply t
+__npi_hsplit args
+  = let scalarArgs
+          = catMaybes
+              [("indices",) . showValue <$> (args !? #indices :: Maybe [Int]),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
+               ("squeeze_axis",) . showValue <$>
+                 (args !? #squeeze_axis :: Maybe Bool),
+               ("sections",) . showValue <$> (args !? #sections :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_hsplit" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_hsplit_backward" t = '[]
+
+__npi_hsplit_backward ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__npi_hsplit_backward" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__npi_hsplit_backward" t a -> TensorApply t
+__npi_hsplit_backward args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_npi_hsplit_backward" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_hypot" t =
+     '[ '("x1", AttrOpt t), '("x2", AttrOpt t)]
+
+__npi_hypot ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__npi_hypot" t a, HasCallStack) =>
+              ArgsHMap "__npi_hypot" t a -> TensorApply t
+__npi_hypot args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("x1",) <$> (args !? #x1 :: Maybe t),
+               ("x2",) <$> (args !? #x2 :: Maybe t)]
+      in
+      apply "_npi_hypot" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_identity" t =
+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["bool", "float16", "float32", "float64", "int32", "int64",
+                 "int8", "uint8"]))]
+
+__npi_identity ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__npi_identity" t a, HasCallStack) =>
+                 ArgsHMap "__npi_identity" t a -> TensorApply t
+__npi_identity args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["bool", "float16", "float32", "float64", "int32", "int64",
+                           "int8", "uint8"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_npi_identity" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_indices" t =
+     '[ '("dimensions", AttrReq [Int]),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "int8",
+                 "uint8"])),
+        '("ctx", AttrOpt Text)]
+
+__npi_indices ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__npi_indices" t a, HasCallStack) =>
+                ArgsHMap "__npi_indices" t a -> TensorApply t
+__npi_indices args
+  = let scalarArgs
+          = catMaybes
+              [("dimensions",) . showValue <$>
+                 (args !? #dimensions :: Maybe [Int]),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "int8",
+                           "uint8"])),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text)]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_npi_indices" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_lcm" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_lcm ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__npi_lcm" t a, HasCallStack) =>
+            ArgsHMap "__npi_lcm" t a -> TensorApply t
+__npi_lcm args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_lcm" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_lcm_scalar" t =
+     '[ '("scalar", AttrOpt Int), '("data", AttrOpt t)]
+
+__npi_lcm_scalar ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__npi_lcm_scalar" t a, HasCallStack) =>
+                   ArgsHMap "__npi_lcm_scalar" t a -> TensorApply t
+__npi_lcm_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_lcm_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_ldexp" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_ldexp ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__npi_ldexp" t a, HasCallStack) =>
+              ArgsHMap "__npi_ldexp" t a -> TensorApply t
+__npi_ldexp args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_ldexp" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_ldexp_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_ldexp_scalar ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__npi_ldexp_scalar" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__npi_ldexp_scalar" t a -> TensorApply t
+__npi_ldexp_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_ldexp_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_less" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_less ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_less" t a, HasCallStack) =>
+             ArgsHMap "__npi_less" t a -> TensorApply t
+__npi_less args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_less" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_less_equal" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_less_equal ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__npi_less_equal" t a, HasCallStack) =>
+                   ArgsHMap "__npi_less_equal" t a -> TensorApply t
+__npi_less_equal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_less_equal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_less_equal_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_less_equal_scalar ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__npi_less_equal_scalar" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__npi_less_equal_scalar" t a -> TensorApply t
+__npi_less_equal_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_less_equal_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_less_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_less_scalar ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__npi_less_scalar" t a, HasCallStack) =>
+                    ArgsHMap "__npi_less_scalar" t a -> TensorApply t
+__npi_less_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_less_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_log" t = '[ '("x", AttrOpt t)]
+
+__npi_log ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__npi_log" t a, HasCallStack) =>
+            ArgsHMap "__npi_log" t a -> TensorApply t
+__npi_log args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_log" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_log10" t = '[ '("x", AttrOpt t)]
+
+__npi_log10 ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__npi_log10" t a, HasCallStack) =>
+              ArgsHMap "__npi_log10" t a -> TensorApply t
+__npi_log10 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_log10" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_log1p" t = '[ '("x", AttrOpt t)]
+
+__npi_log1p ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__npi_log1p" t a, HasCallStack) =>
+              ArgsHMap "__npi_log1p" t a -> TensorApply t
+__npi_log1p args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_log1p" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_log2" t = '[ '("x", AttrOpt t)]
+
+__npi_log2 ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_log2" t a, HasCallStack) =>
+             ArgsHMap "__npi_log2" t a -> TensorApply t
+__npi_log2 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_log2" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_logical_not" t =
+     '[ '("x", AttrOpt t)]
+
+__npi_logical_not ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__npi_logical_not" t a, HasCallStack) =>
+                    ArgsHMap "__npi_logical_not" t a -> TensorApply t
+__npi_logical_not args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_logical_not" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_logspace" t =
+     '[ '("start", AttrReq Double), '("stop", AttrReq Double),
+        '("num", AttrReq Int), '("endpoint", AttrOpt Bool),
+        '("base", AttrOpt Double), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "int8",
+                 "uint8"]))]
+
+__npi_logspace ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__npi_logspace" t a, HasCallStack) =>
+                 ArgsHMap "__npi_logspace" t a -> TensorApply t
+__npi_logspace args
+  = let scalarArgs
+          = catMaybes
+              [("start",) . showValue <$> (args !? #start :: Maybe Double),
+               ("stop",) . showValue <$> (args !? #stop :: Maybe Double),
+               ("num",) . showValue <$> (args !? #num :: Maybe Int),
+               ("endpoint",) . showValue <$> (args !? #endpoint :: Maybe Bool),
+               ("base",) . showValue <$> (args !? #base :: Maybe Double),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "int8",
+                           "uint8"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_npi_logspace" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_mean" t =
+     '[ '("axis", AttrOpt (Maybe [Int])),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["bool", "float16", "float32", "float64", "int32", "int64",
+                    "int8"]))),
+        '("keepdims", AttrOpt Bool), '("initial", AttrOpt (Maybe Double)),
+        '("a", AttrOpt t)]
+
+__npi_mean ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_mean" t a, HasCallStack) =>
+             ArgsHMap "__npi_mean" t a -> TensorApply t
+__npi_mean args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["bool", "float16", "float32", "float64", "int32", "int64",
+                              "int8"]))),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
+               ("initial",) . showValue <$>
+                 (args !? #initial :: Maybe (Maybe Double))]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_npi_mean" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_mod" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_mod ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__npi_mod" t a, HasCallStack) =>
+            ArgsHMap "__npi_mod" t a -> TensorApply t
+__npi_mod args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_mod" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_mod_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_mod_scalar ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__npi_mod_scalar" t a, HasCallStack) =>
+                   ArgsHMap "__npi_mod_scalar" t a -> TensorApply t
+__npi_mod_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_mod_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_multinomial" t =
+     '[ '("n", AttrReq Int), '("pvals", AttrOpt Int),
+        '("size", AttrOpt (Maybe [Int])), '("a", AttrOpt t)]
+
+__npi_multinomial ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__npi_multinomial" t a, HasCallStack) =>
+                    ArgsHMap "__npi_multinomial" t a -> TensorApply t
+__npi_multinomial args
+  = let scalarArgs
+          = catMaybes
+              [("n",) . showValue <$> (args !? #n :: Maybe Int),
+               ("pvals",) . showValue <$> (args !? #pvals :: Maybe Int),
+               ("size",) . showValue <$> (args !? #size :: Maybe (Maybe [Int]))]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_npi_multinomial" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_multiply" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_multiply ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__npi_multiply" t a, HasCallStack) =>
+                 ArgsHMap "__npi_multiply" t a -> TensorApply t
+__npi_multiply args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_multiply" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_multiply_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_multiply_scalar ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__npi_multiply_scalar" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__npi_multiply_scalar" t a -> TensorApply t
+__npi_multiply_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_multiply_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_negative" t =
+     '[ '("x", AttrOpt t)]
+
+__npi_negative ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__npi_negative" t a, HasCallStack) =>
+                 ArgsHMap "__npi_negative" t a -> TensorApply t
+__npi_negative args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_negative" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_normal" t =
+     '[ '("loc", AttrReq (Maybe Float)),
+        '("scale", AttrReq (Maybe Float)),
+        '("size", AttrOpt (Maybe [Int])), '("ctx", AttrOpt Text),
+        '("dtype", AttrOpt (EnumType '["float16", "float32", "float64"])),
+        '("input1", AttrOpt t), '("input2", AttrOpt t)]
+
+__npi_normal ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_normal" t a, HasCallStack) =>
+               ArgsHMap "__npi_normal" t a -> TensorApply t
+__npi_normal args
+  = let scalarArgs
+          = catMaybes
+              [("loc",) . showValue <$> (args !? #loc :: Maybe (Maybe Float)),
+               ("scale",) . showValue <$> (args !? #scale :: Maybe (Maybe Float)),
+               ("size",) . showValue <$> (args !? #size :: Maybe (Maybe [Int])),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["float16", "float32", "float64"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("input1",) <$> (args !? #input1 :: Maybe t),
+               ("input2",) <$> (args !? #input2 :: Maybe t)]
+      in
+      apply "_npi_normal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_not_equal" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_not_equal ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__npi_not_equal" t a, HasCallStack) =>
+                  ArgsHMap "__npi_not_equal" t a -> TensorApply t
+__npi_not_equal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_not_equal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_not_equal_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_not_equal_scalar ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__npi_not_equal_scalar" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__npi_not_equal_scalar" t a -> TensorApply t
+__npi_not_equal_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_not_equal_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_ones" t =
+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["bool", "float16", "float32", "float64", "int32", "int64",
+                 "int8", "uint8"]))]
+
+__npi_ones ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_ones" t a, HasCallStack) =>
+             ArgsHMap "__npi_ones" t a -> TensorApply t
+__npi_ones args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["bool", "float16", "float32", "float64", "int32", "int64",
+                           "int8", "uint8"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_npi_ones" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_power" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_power ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__npi_power" t a, HasCallStack) =>
+              ArgsHMap "__npi_power" t a -> TensorApply t
+__npi_power args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_power" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_power_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_power_scalar ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__npi_power_scalar" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__npi_power_scalar" t a -> TensorApply t
+__npi_power_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_power_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_radians" t =
+     '[ '("x", AttrOpt t)]
+
+__npi_radians ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__npi_radians" t a, HasCallStack) =>
+                ArgsHMap "__npi_radians" t a -> TensorApply t
+__npi_radians args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_radians" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_rarctan2_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_rarctan2_scalar ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__npi_rarctan2_scalar" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__npi_rarctan2_scalar" t a -> TensorApply t
+__npi_rarctan2_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_rarctan2_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_rcopysign_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_rcopysign_scalar ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__npi_rcopysign_scalar" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__npi_rcopysign_scalar" t a -> TensorApply t
+__npi_rcopysign_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_rcopysign_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_reciprocal" t =
+     '[ '("x", AttrOpt t)]
+
+__npi_reciprocal ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__npi_reciprocal" t a, HasCallStack) =>
+                   ArgsHMap "__npi_reciprocal" t a -> TensorApply t
+__npi_reciprocal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_reciprocal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_rint" t = '[ '("x", AttrOpt t)]
+
+__npi_rint ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_rint" t a, HasCallStack) =>
+             ArgsHMap "__npi_rint" t a -> TensorApply t
+__npi_rint args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_rint" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_rldexp_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_rldexp_scalar ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__npi_rldexp_scalar" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__npi_rldexp_scalar" t a -> TensorApply t
+__npi_rldexp_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_rldexp_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_rmod_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_rmod_scalar ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__npi_rmod_scalar" t a, HasCallStack) =>
+                    ArgsHMap "__npi_rmod_scalar" t a -> TensorApply t
+__npi_rmod_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_rmod_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_rot90" t =
+     '[ '("k", AttrOpt Int), '("axes", AttrOpt (Maybe [Int])),
+        '("data", AttrOpt t)]
+
+__npi_rot90 ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__npi_rot90" t a, HasCallStack) =>
+              ArgsHMap "__npi_rot90" t a -> TensorApply t
+__npi_rot90 args
+  = let scalarArgs
+          = catMaybes
+              [("k",) . showValue <$> (args !? #k :: Maybe Int),
+               ("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_rot90" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_rpower_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_rpower_scalar ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__npi_rpower_scalar" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__npi_rpower_scalar" t a -> TensorApply t
+__npi_rpower_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_rpower_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_rsubtract_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_rsubtract_scalar ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__npi_rsubtract_scalar" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__npi_rsubtract_scalar" t a -> TensorApply t
+__npi_rsubtract_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_rsubtract_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_rtrue_divide_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_rtrue_divide_scalar ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "__npi_rtrue_divide_scalar" t a,
+                             HasCallStack) =>
+                            ArgsHMap "__npi_rtrue_divide_scalar" t a -> TensorApply t
+__npi_rtrue_divide_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_rtrue_divide_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_share_memory" t =
+     '[ '("a", AttrOpt t), '("b", AttrOpt t)]
+
+__npi_share_memory ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__npi_share_memory" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__npi_share_memory" t a -> TensorApply t
+__npi_share_memory args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("a",) <$> (args !? #a :: Maybe t),
+               ("b",) <$> (args !? #b :: Maybe t)]
+      in
+      apply "_npi_share_memory" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_sign" t = '[ '("x", AttrOpt t)]
+
+__npi_sign ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_sign" t a, HasCallStack) =>
+             ArgsHMap "__npi_sign" t a -> TensorApply t
+__npi_sign args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_sign" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_sin" t = '[ '("x", AttrOpt t)]
+
+__npi_sin ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__npi_sin" t a, HasCallStack) =>
+            ArgsHMap "__npi_sin" t a -> TensorApply t
+__npi_sin args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_sin" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_sinh" t = '[ '("x", AttrOpt t)]
+
+__npi_sinh ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_sinh" t a, HasCallStack) =>
+             ArgsHMap "__npi_sinh" t a -> TensorApply t
+__npi_sinh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_sinh" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_sqrt" t = '[ '("x", AttrOpt t)]
+
+__npi_sqrt ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_sqrt" t a, HasCallStack) =>
+             ArgsHMap "__npi_sqrt" t a -> TensorApply t
+__npi_sqrt args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_sqrt" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_square" t =
+     '[ '("x", AttrOpt t)]
+
+__npi_square ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_square" t a, HasCallStack) =>
+               ArgsHMap "__npi_square" t a -> TensorApply t
+__npi_square args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_square" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_stack" t =
+     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),
+        '("data", AttrOpt [t])]
+
+__npi_stack ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__npi_stack" t a, HasCallStack) =>
+              ArgsHMap "__npi_stack" t a -> TensorApply t
+__npi_stack args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "_npi_stack" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__npi_std" t =
+     '[ '("axis", AttrOpt (Maybe [Int])),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["float16", "float32", "float64", "int32", "int64", "int8"]))),
+        '("ddof", AttrOpt Int), '("keepdims", AttrOpt Bool),
+        '("a", AttrOpt t)]
+
+__npi_std ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__npi_std" t a, HasCallStack) =>
+            ArgsHMap "__npi_std" t a -> TensorApply t
+__npi_std args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["float16", "float32", "float64", "int32", "int64", "int8"]))),
+               ("ddof",) . showValue <$> (args !? #ddof :: Maybe Int),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_npi_std" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_subtract" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_subtract ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__npi_subtract" t a, HasCallStack) =>
+                 ArgsHMap "__npi_subtract" t a -> TensorApply t
+__npi_subtract args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_subtract" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_subtract_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_subtract_scalar ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__npi_subtract_scalar" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__npi_subtract_scalar" t a -> TensorApply t
+__npi_subtract_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_subtract_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_svd" t = '[ '("a", AttrOpt t)]
+
+__npi_svd ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__npi_svd" t a, HasCallStack) =>
+            ArgsHMap "__npi_svd" t a -> TensorApply t
+__npi_svd args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_npi_svd" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_tan" t = '[ '("x", AttrOpt t)]
+
+__npi_tan ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__npi_tan" t a, HasCallStack) =>
+            ArgsHMap "__npi_tan" t a -> TensorApply t
+__npi_tan args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_tan" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_tanh" t = '[ '("x", AttrOpt t)]
+
+__npi_tanh ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_tanh" t a, HasCallStack) =>
+             ArgsHMap "__npi_tanh" t a -> TensorApply t
+__npi_tanh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_tanh" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_tensordot" t =
+     '[ '("a_axes_summed", AttrReq [Int]),
+        '("b_axes_summed", AttrReq [Int]), '("a", AttrOpt t),
+        '("b", AttrOpt t)]
+
+__npi_tensordot ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__npi_tensordot" t a, HasCallStack) =>
+                  ArgsHMap "__npi_tensordot" t a -> TensorApply t
+__npi_tensordot args
+  = let scalarArgs
+          = catMaybes
+              [("a_axes_summed",) . showValue <$>
+                 (args !? #a_axes_summed :: Maybe [Int]),
+               ("b_axes_summed",) . showValue <$>
+                 (args !? #b_axes_summed :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes
+              [("a",) <$> (args !? #a :: Maybe t),
+               ("b",) <$> (args !? #b :: Maybe t)]
+      in
+      apply "_npi_tensordot" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_tensordot_int_axes" t =
+     '[ '("axes", AttrReq Int), '("a", AttrOpt t), '("b", AttrOpt t)]
+
+__npi_tensordot_int_axes ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__npi_tensordot_int_axes" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__npi_tensordot_int_axes" t a -> TensorApply t
+__npi_tensordot_int_axes args
+  = let scalarArgs
+          = catMaybes
+              [("axes",) . showValue <$> (args !? #axes :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes
+              [("a",) <$> (args !? #a :: Maybe t),
+               ("b",) <$> (args !? #b :: Maybe t)]
+      in
+      apply "_npi_tensordot_int_axes" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_tril" t =
+     '[ '("k", AttrOpt Int), '("data", AttrOpt t)]
+
+__npi_tril ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npi_tril" t a, HasCallStack) =>
+             ArgsHMap "__npi_tril" t a -> TensorApply t
+__npi_tril args
+  = let scalarArgs
+          = catMaybes [("k",) . showValue <$> (args !? #k :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_tril" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_true_divide" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__npi_true_divide ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "__npi_true_divide" t a, HasCallStack) =>
+                    ArgsHMap "__npi_true_divide" t a -> TensorApply t
+__npi_true_divide args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_npi_true_divide" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_true_divide_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__npi_true_divide_scalar ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__npi_true_divide_scalar" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__npi_true_divide_scalar" t a -> TensorApply t
+__npi_true_divide_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_true_divide_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_trunc" t = '[ '("x", AttrOpt t)]
+
+__npi_trunc ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__npi_trunc" t a, HasCallStack) =>
+              ArgsHMap "__npi_trunc" t a -> TensorApply t
+__npi_trunc args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npi_trunc" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_uniform" t =
+     '[ '("low", AttrReq (Maybe Float)),
+        '("high", AttrReq (Maybe Float)), '("size", AttrOpt (Maybe [Int])),
+        '("ctx", AttrOpt Text),
+        '("dtype", AttrOpt (EnumType '["float16", "float32", "float64"])),
+        '("input1", AttrOpt t), '("input2", AttrOpt t)]
+
+__npi_uniform ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__npi_uniform" t a, HasCallStack) =>
+                ArgsHMap "__npi_uniform" t a -> TensorApply t
+__npi_uniform args
+  = let scalarArgs
+          = catMaybes
+              [("low",) . showValue <$> (args !? #low :: Maybe (Maybe Float)),
+               ("high",) . showValue <$> (args !? #high :: Maybe (Maybe Float)),
+               ("size",) . showValue <$> (args !? #size :: Maybe (Maybe [Int])),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["float16", "float32", "float64"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("input1",) <$> (args !? #input1 :: Maybe t),
+               ("input2",) <$> (args !? #input2 :: Maybe t)]
+      in
+      apply "_npi_uniform" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_unique" t =
+     '[ '("return_index", AttrOpt Bool),
+        '("return_inverse", AttrOpt Bool),
+        '("return_counts", AttrOpt Bool), '("axis", AttrOpt (Maybe Int)),
+        '("data", AttrOpt t)]
+
+__npi_unique ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_unique" t a, HasCallStack) =>
+               ArgsHMap "__npi_unique" t a -> TensorApply t
+__npi_unique args
+  = let scalarArgs
+          = catMaybes
+              [("return_index",) . showValue <$>
+                 (args !? #return_index :: Maybe Bool),
+               ("return_inverse",) . showValue <$>
+                 (args !? #return_inverse :: Maybe Bool),
+               ("return_counts",) . showValue <$>
+                 (args !? #return_counts :: Maybe Bool),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npi_unique" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_var" t =
+     '[ '("axis", AttrOpt (Maybe [Int])),
+        '("dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["float16", "float32", "float64", "int32", "int64", "int8"]))),
+        '("ddof", AttrOpt Int), '("keepdims", AttrOpt Bool),
+        '("a", AttrOpt t)]
+
+__npi_var ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__npi_var" t a, HasCallStack) =>
+            ArgsHMap "__npi_var" t a -> TensorApply t
+__npi_var args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["float16", "float32", "float64", "int32", "int64", "int8"]))),
+               ("ddof",) . showValue <$> (args !? #ddof :: Maybe Int),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_npi_var" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npi_vstack" t =
+     '[ '("num_args", AttrReq Int), '("data", AttrOpt [t])]
+
+__npi_vstack ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__npi_vstack" t a, HasCallStack) =>
+               ArgsHMap "__npi_vstack" t a -> TensorApply t
+__npi_vstack args
+  = let scalarArgs
+          = catMaybes
+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "_npi_vstack" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__npi_zeros" t =
+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["bool", "float16", "float32", "float64", "int32", "int64",
+                 "int8", "uint8"]))]
+
+__npi_zeros ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__npi_zeros" t a, HasCallStack) =>
+              ArgsHMap "__npi_zeros" t a -> TensorApply t
+__npi_zeros args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["bool", "float16", "float32", "float64", "int32", "int64",
+                           "int8", "uint8"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_npi_zeros" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npx_nonzero" t =
+     '[ '("x", AttrOpt t)]
+
+__npx_nonzero ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__npx_nonzero" t a, HasCallStack) =>
+                ArgsHMap "__npx_nonzero" t a -> TensorApply t
+__npx_nonzero args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes [("x",) <$> (args !? #x :: Maybe t)]
+      in
+      apply "_npx_nonzero" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npx_relu" t =
+     '[ '("data", AttrOpt t)]
+
+__npx_relu ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__npx_relu" t a, HasCallStack) =>
+             ArgsHMap "__npx_relu" t a -> TensorApply t
+__npx_relu args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npx_relu" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npx_reshape" t =
+     '[ '("newshape", AttrReq [Int]), '("reverse", AttrOpt Bool),
+        '("order", AttrOpt Text), '("a", AttrOpt t)]
+
+__npx_reshape ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__npx_reshape" t a, HasCallStack) =>
+                ArgsHMap "__npx_reshape" t a -> TensorApply t
+__npx_reshape args
+  = let scalarArgs
+          = catMaybes
+              [("newshape",) . showValue <$> (args !? #newshape :: Maybe [Int]),
+               ("reverse",) . showValue <$> (args !? #reverse :: Maybe Bool),
+               ("order",) . showValue <$> (args !? #order :: Maybe Text)]
+        tensorKeyArgs = catMaybes [("a",) <$> (args !? #a :: Maybe t)]
+      in
+      apply "_npx_reshape" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__npx_sigmoid" t =
+     '[ '("data", AttrOpt t)]
+
+__npx_sigmoid ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__npx_sigmoid" t a, HasCallStack) =>
+                ArgsHMap "__npx_sigmoid" t a -> TensorApply t
+__npx_sigmoid args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_npx_sigmoid" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__onehot_encode" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__onehot_encode ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__onehot_encode" t a, HasCallStack) =>
+                  ArgsHMap "__onehot_encode" t a -> TensorApply t
+__onehot_encode args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_onehot_encode" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__ones" t =
+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["bool", "float16", "float32", "float64", "int32", "int64",
+                 "int8", "uint8"]))]
+
+__ones ::
+       forall a t .
+         (TensorOp t t, Fullfilled "__ones" t a, HasCallStack) =>
+         ArgsHMap "__ones" t a -> TensorApply t
+__ones args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["bool", "float16", "float32", "float64", "int32", "int64",
+                           "int8", "uint8"]))]
+        tensorKeyArgs = catMaybes []
+      in apply "_ones" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__plus_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__plus_scalar ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__plus_scalar" t a, HasCallStack) =>
+                ArgsHMap "__plus_scalar" t a -> TensorApply t
+__plus_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_plus_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__power" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__power ::
+        forall a t .
+          (TensorOp t t, Fullfilled "__power" t a, HasCallStack) =>
+          ArgsHMap "__power" t a -> TensorApply t
+__power args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in apply "_power" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__power_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__power_scalar ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__power_scalar" t a, HasCallStack) =>
+                 ArgsHMap "__power_scalar" t a -> TensorApply t
+__power_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_power_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_exponential" t =
+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
+        '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
+
+__random_exponential ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__random_exponential" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__random_exponential" t a -> TensorApply t
+__random_exponential args
+  = let scalarArgs
+          = catMaybes
+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_random_exponential" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_exponential_like" t =
+     '[ '("lam", AttrOpt Float), '("data", AttrOpt t)]
+
+__random_exponential_like ::
+                          forall a t .
+                            (TensorOp t t, Fullfilled "__random_exponential_like" t a,
+                             HasCallStack) =>
+                            ArgsHMap "__random_exponential_like" t a -> TensorApply t
+__random_exponential_like args
+  = let scalarArgs
+          = catMaybes
+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_random_exponential_like" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_gamma" t =
+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
+
+__random_gamma ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__random_gamma" t a, HasCallStack) =>
+                 ArgsHMap "__random_gamma" t a -> TensorApply t
+__random_gamma args
+  = let scalarArgs
+          = catMaybes
+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_random_gamma" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_gamma_like" t =
+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
+        '("data", AttrOpt t)]
+
+__random_gamma_like ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__random_gamma_like" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__random_gamma_like" t a -> TensorApply t
+__random_gamma_like args
+  = let scalarArgs
+          = catMaybes
+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_random_gamma_like" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__random_generalized_negative_binomial" t =
+     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),
+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
+
+__random_generalized_negative_binomial ::
+                                       forall a t .
+                                         (TensorOp t t,
+                                          Fullfilled "__random_generalized_negative_binomial" t a,
+                                          HasCallStack) =>
+                                         ArgsHMap "__random_generalized_negative_binomial" t a ->
+                                           TensorApply t
+__random_generalized_negative_binomial args
+  = let scalarArgs
+          = catMaybes
+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_random_generalized_negative_binomial" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__random_generalized_negative_binomial_like" t =
+     '[ '("mu", AttrOpt Float), '("alpha", AttrOpt Float),
+        '("data", AttrOpt t)]
+
+__random_generalized_negative_binomial_like ::
+                                            forall a t .
+                                              (TensorOp t t,
+                                               Fullfilled
+                                                 "__random_generalized_negative_binomial_like" t a,
+                                               HasCallStack) =>
+                                              ArgsHMap "__random_generalized_negative_binomial_like"
+                                                t
+                                                a
+                                                -> TensorApply t
+__random_generalized_negative_binomial_like args
+  = let scalarArgs
+          = catMaybes
+              [("mu",) . showValue <$> (args !? #mu :: Maybe Float),
+               ("alpha",) . showValue <$> (args !? #alpha :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_random_generalized_negative_binomial_like" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_negative_binomial" t =
+     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),
+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
+
+__random_negative_binomial ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__random_negative_binomial" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__random_negative_binomial" t a -> TensorApply t
+__random_negative_binomial args
+  = let scalarArgs
+          = catMaybes
+              [("k",) . showValue <$> (args !? #k :: Maybe Int),
+               ("p",) . showValue <$> (args !? #p :: Maybe Float),
+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_random_negative_binomial" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_negative_binomial_like" t =
+     '[ '("k", AttrOpt Int), '("p", AttrOpt Float),
+        '("data", AttrOpt t)]
+
+__random_negative_binomial_like ::
+                                forall a t .
+                                  (TensorOp t t, Fullfilled "__random_negative_binomial_like" t a,
+                                   HasCallStack) =>
+                                  ArgsHMap "__random_negative_binomial_like" t a -> TensorApply t
+__random_negative_binomial_like args
+  = let scalarArgs
+          = catMaybes
+              [("k",) . showValue <$> (args !? #k :: Maybe Int),
+               ("p",) . showValue <$> (args !? #p :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_random_negative_binomial_like" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_normal" t =
+     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),
+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
+
+__random_normal ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__random_normal" t a, HasCallStack) =>
+                  ArgsHMap "__random_normal" t a -> TensorApply t
+__random_normal args
+  = let scalarArgs
+          = catMaybes
+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float),
+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_random_normal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_normal_like" t =
+     '[ '("loc", AttrOpt Float), '("scale", AttrOpt Float),
+        '("data", AttrOpt t)]
+
+__random_normal_like ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__random_normal_like" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__random_normal_like" t a -> TensorApply t
+__random_normal_like args
+  = let scalarArgs
+          = catMaybes
+              [("loc",) . showValue <$> (args !? #loc :: Maybe Float),
+               ("scale",) . showValue <$> (args !? #scale :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_random_normal_like" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_pdf_dirichlet" t =
+     '[ '("is_log", AttrOpt Bool), '("sample", AttrOpt t),
+        '("alpha", AttrOpt t)]
+
+__random_pdf_dirichlet ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__random_pdf_dirichlet" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__random_pdf_dirichlet" t a -> TensorApply t
+__random_pdf_dirichlet args
+  = let scalarArgs
+          = catMaybes
+              [("is_log",) . showValue <$> (args !? #is_log :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("sample",) <$> (args !? #sample :: Maybe t),
+               ("alpha",) <$> (args !? #alpha :: Maybe t)]
+      in
+      apply "_random_pdf_dirichlet" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_pdf_exponential" t =
+     '[ '("is_log", AttrOpt Bool), '("sample", AttrOpt t),
+        '("lam", AttrOpt t)]
+
+__random_pdf_exponential ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "__random_pdf_exponential" t a,
+                            HasCallStack) =>
+                           ArgsHMap "__random_pdf_exponential" t a -> TensorApply t
+__random_pdf_exponential args
+  = let scalarArgs
+          = catMaybes
+              [("is_log",) . showValue <$> (args !? #is_log :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("sample",) <$> (args !? #sample :: Maybe t),
+               ("lam",) <$> (args !? #lam :: Maybe t)]
+      in
+      apply "_random_pdf_exponential" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_pdf_gamma" t =
+     '[ '("is_log", AttrOpt Bool), '("sample", AttrOpt t),
+        '("alpha", AttrOpt t), '("beta", AttrOpt t)]
+
+__random_pdf_gamma ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__random_pdf_gamma" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__random_pdf_gamma" t a -> TensorApply t
+__random_pdf_gamma args
+  = let scalarArgs
+          = catMaybes
+              [("is_log",) . showValue <$> (args !? #is_log :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("sample",) <$> (args !? #sample :: Maybe t),
+               ("alpha",) <$> (args !? #alpha :: Maybe t),
+               ("beta",) <$> (args !? #beta :: Maybe t)]
+      in
+      apply "_random_pdf_gamma" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__random_pdf_generalized_negative_binomial" t =
+     '[ '("is_log", AttrOpt Bool), '("sample", AttrOpt t),
+        '("mu", AttrOpt t), '("alpha", AttrOpt t)]
+
+__random_pdf_generalized_negative_binomial ::
+                                           forall a t .
+                                             (TensorOp t t,
+                                              Fullfilled
+                                                "__random_pdf_generalized_negative_binomial" t a,
+                                              HasCallStack) =>
+                                             ArgsHMap "__random_pdf_generalized_negative_binomial" t
+                                               a
+                                               -> TensorApply t
+__random_pdf_generalized_negative_binomial args
+  = let scalarArgs
+          = catMaybes
+              [("is_log",) . showValue <$> (args !? #is_log :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("sample",) <$> (args !? #sample :: Maybe t),
+               ("mu",) <$> (args !? #mu :: Maybe t),
+               ("alpha",) <$> (args !? #alpha :: Maybe t)]
+      in
+      apply "_random_pdf_generalized_negative_binomial" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_pdf_negative_binomial" t =
+     '[ '("is_log", AttrOpt Bool), '("sample", AttrOpt t),
+        '("k", AttrOpt t), '("p", AttrOpt t)]
+
+__random_pdf_negative_binomial ::
+                               forall a t .
+                                 (TensorOp t t, Fullfilled "__random_pdf_negative_binomial" t a,
+                                  HasCallStack) =>
+                                 ArgsHMap "__random_pdf_negative_binomial" t a -> TensorApply t
+__random_pdf_negative_binomial args
+  = let scalarArgs
+          = catMaybes
+              [("is_log",) . showValue <$> (args !? #is_log :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("sample",) <$> (args !? #sample :: Maybe t),
+               ("k",) <$> (args !? #k :: Maybe t),
+               ("p",) <$> (args !? #p :: Maybe t)]
+      in
+      apply "_random_pdf_negative_binomial" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_pdf_normal" t =
+     '[ '("is_log", AttrOpt Bool), '("sample", AttrOpt t),
+        '("mu", AttrOpt t), '("sigma", AttrOpt t)]
+
+__random_pdf_normal ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__random_pdf_normal" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__random_pdf_normal" t a -> TensorApply t
+__random_pdf_normal args
+  = let scalarArgs
+          = catMaybes
+              [("is_log",) . showValue <$> (args !? #is_log :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("sample",) <$> (args !? #sample :: Maybe t),
+               ("mu",) <$> (args !? #mu :: Maybe t),
+               ("sigma",) <$> (args !? #sigma :: Maybe t)]
+      in
+      apply "_random_pdf_normal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_pdf_poisson" t =
+     '[ '("is_log", AttrOpt Bool), '("sample", AttrOpt t),
+        '("lam", AttrOpt t)]
+
+__random_pdf_poisson ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__random_pdf_poisson" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__random_pdf_poisson" t a -> TensorApply t
+__random_pdf_poisson args
+  = let scalarArgs
+          = catMaybes
+              [("is_log",) . showValue <$> (args !? #is_log :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("sample",) <$> (args !? #sample :: Maybe t),
+               ("lam",) <$> (args !? #lam :: Maybe t)]
+      in
+      apply "_random_pdf_poisson" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_pdf_uniform" t =
+     '[ '("is_log", AttrOpt Bool), '("sample", AttrOpt t),
+        '("low", AttrOpt t), '("high", AttrOpt t)]
+
+__random_pdf_uniform ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__random_pdf_uniform" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__random_pdf_uniform" t a -> TensorApply t
+__random_pdf_uniform args
+  = let scalarArgs
+          = catMaybes
+              [("is_log",) . showValue <$> (args !? #is_log :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("sample",) <$> (args !? #sample :: Maybe t),
+               ("low",) <$> (args !? #low :: Maybe t),
+               ("high",) <$> (args !? #high :: Maybe t)]
+      in
+      apply "_random_pdf_uniform" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_poisson" t =
+     '[ '("lam", AttrOpt Float), '("shape", AttrOpt [Int]),
+        '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
+
+__random_poisson ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__random_poisson" t a, HasCallStack) =>
+                   ArgsHMap "__random_poisson" t a -> TensorApply t
+__random_poisson args
+  = let scalarArgs
+          = catMaybes
+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float),
+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_random_poisson" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_poisson_like" t =
+     '[ '("lam", AttrOpt Float), '("data", AttrOpt t)]
+
+__random_poisson_like ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__random_poisson_like" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__random_poisson_like" t a -> TensorApply t
+__random_poisson_like args
+  = let scalarArgs
+          = catMaybes
+              [("lam",) . showValue <$> (args !? #lam :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_random_poisson_like" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_uniform" t =
+     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),
+        '("shape", AttrOpt [Int]), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt (EnumType '["None", "float16", "float32", "float64"]))]
+
+__random_uniform ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__random_uniform" t a, HasCallStack) =>
+                   ArgsHMap "__random_uniform" t a -> TensorApply t
+__random_uniform args
+  = let scalarArgs
+          = catMaybes
+              [("low",) . showValue <$> (args !? #low :: Maybe Float),
+               ("high",) . showValue <$> (args !? #high :: Maybe Float),
+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_random_uniform" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__random_uniform_like" t =
+     '[ '("low", AttrOpt Float), '("high", AttrOpt Float),
+        '("data", AttrOpt t)]
+
+__random_uniform_like ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__random_uniform_like" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__random_uniform_like" t a -> TensorApply t
+__random_uniform_like args
+  = let scalarArgs
+          = catMaybes
+              [("low",) . showValue <$> (args !? #low :: Maybe Float),
+               ("high",) . showValue <$> (args !? #high :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_random_uniform_like" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__ravel_multi_index" t =
+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt t)]
+
+__ravel_multi_index ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__ravel_multi_index" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__ravel_multi_index" t a -> TensorApply t
+__ravel_multi_index args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_ravel_multi_index" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__rdiv_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__rdiv_scalar ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__rdiv_scalar" t a, HasCallStack) =>
+                ArgsHMap "__rdiv_scalar" t a -> TensorApply t
+__rdiv_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_rdiv_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__rminus_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__rminus_scalar ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__rminus_scalar" t a, HasCallStack) =>
+                  ArgsHMap "__rminus_scalar" t a -> TensorApply t
+__rminus_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_rminus_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__rmod_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__rmod_scalar ::
+              forall a t .
+                (TensorOp t t, Fullfilled "__rmod_scalar" t a, HasCallStack) =>
+                ArgsHMap "__rmod_scalar" t a -> TensorApply t
+__rmod_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_rmod_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__rnn_param_concat" t =
+     '[ '("num_args", AttrReq Int), '("dim", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+__rnn_param_concat ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "__rnn_param_concat" t a,
+                      HasCallStack) =>
+                     ArgsHMap "__rnn_param_concat" t a -> TensorApply t
+__rnn_param_concat args
+  = let scalarArgs
+          = catMaybes
+              [("num_args",) . showValue <$> (args !? #num_args :: Maybe Int),
+               ("dim",) . showValue <$> (args !? #dim :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "_rnn_param_concat" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "__rpower_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__rpower_scalar ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__rpower_scalar" t a, HasCallStack) =>
+                  ArgsHMap "__rpower_scalar" t a -> TensorApply t
+__rpower_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_rpower_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__sample_exponential" t =
+     '[ '("shape", AttrOpt [Int]),
+        '("dtype",
+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
+        '("lam", AttrOpt t)]
+
+__sample_exponential ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__sample_exponential" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__sample_exponential" t a -> TensorApply t
+__sample_exponential args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
+        tensorKeyArgs = catMaybes [("lam",) <$> (args !? #lam :: Maybe t)]
+      in
+      apply "_sample_exponential" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__sample_gamma" t =
+     '[ '("shape", AttrOpt [Int]),
+        '("dtype",
+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
+        '("alpha", AttrOpt t), '("beta", AttrOpt t)]
+
+__sample_gamma ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__sample_gamma" t a, HasCallStack) =>
+                 ArgsHMap "__sample_gamma" t a -> TensorApply t
+__sample_gamma args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("alpha",) <$> (args !? #alpha :: Maybe t),
+               ("beta",) <$> (args !? #beta :: Maybe t)]
+      in
+      apply "_sample_gamma" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance
+     ParameterList "__sample_generalized_negative_binomial" t =
+     '[ '("shape", AttrOpt [Int]),
+        '("dtype",
+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
+        '("mu", AttrOpt t), '("alpha", AttrOpt t)]
+
+__sample_generalized_negative_binomial ::
+                                       forall a t .
+                                         (TensorOp t t,
+                                          Fullfilled "__sample_generalized_negative_binomial" t a,
+                                          HasCallStack) =>
+                                         ArgsHMap "__sample_generalized_negative_binomial" t a ->
+                                           TensorApply t
+__sample_generalized_negative_binomial args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("mu",) <$> (args !? #mu :: Maybe t),
+               ("alpha",) <$> (args !? #alpha :: Maybe t)]
+      in
+      apply "_sample_generalized_negative_binomial" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__sample_multinomial" t =
+     '[ '("shape", AttrOpt [Int]), '("get_prob", AttrOpt Bool),
+        '("dtype",
+          AttrOpt
+            (EnumType '["float16", "float32", "float64", "int32", "uint8"])),
+        '("data", AttrOpt t)]
+
+__sample_multinomial ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "__sample_multinomial" t a,
+                        HasCallStack) =>
+                       ArgsHMap "__sample_multinomial" t a -> TensorApply t
+__sample_multinomial args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("get_prob",) . showValue <$> (args !? #get_prob :: Maybe Bool),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType '["float16", "float32", "float64", "int32", "uint8"]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_sample_multinomial" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__sample_negative_binomial" t =
+     '[ '("shape", AttrOpt [Int]),
+        '("dtype",
+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
+        '("k", AttrOpt t), '("p", AttrOpt t)]
+
+__sample_negative_binomial ::
+                           forall a t .
+                             (TensorOp t t, Fullfilled "__sample_negative_binomial" t a,
+                              HasCallStack) =>
+                             ArgsHMap "__sample_negative_binomial" t a -> TensorApply t
+__sample_negative_binomial args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("k",) <$> (args !? #k :: Maybe t),
+               ("p",) <$> (args !? #p :: Maybe t)]
+      in
+      apply "_sample_negative_binomial" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__sample_normal" t =
+     '[ '("shape", AttrOpt [Int]),
+        '("dtype",
+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
+        '("mu", AttrOpt t), '("sigma", AttrOpt t)]
+
+__sample_normal ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__sample_normal" t a, HasCallStack) =>
+                  ArgsHMap "__sample_normal" t a -> TensorApply t
+__sample_normal args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("mu",) <$> (args !? #mu :: Maybe t),
+               ("sigma",) <$> (args !? #sigma :: Maybe t)]
+      in
+      apply "_sample_normal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__sample_poisson" t =
+     '[ '("shape", AttrOpt [Int]),
+        '("dtype",
+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
+        '("lam", AttrOpt t)]
+
+__sample_poisson ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__sample_poisson" t a, HasCallStack) =>
+                   ArgsHMap "__sample_poisson" t a -> TensorApply t
+__sample_poisson args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
+        tensorKeyArgs = catMaybes [("lam",) <$> (args !? #lam :: Maybe t)]
+      in
+      apply "_sample_poisson" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__sample_uniform" t =
+     '[ '("shape", AttrOpt [Int]),
+        '("dtype",
+          AttrOpt (EnumType '["None", "float16", "float32", "float64"])),
+        '("low", AttrOpt t), '("high", AttrOpt t)]
+
+__sample_uniform ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__sample_uniform" t a, HasCallStack) =>
+                   ArgsHMap "__sample_uniform" t a -> TensorApply t
+__sample_uniform args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (EnumType '["None", "float16", "float32", "float64"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("low",) <$> (args !? #low :: Maybe t),
+               ("high",) <$> (args !? #high :: Maybe t)]
+      in
+      apply "_sample_uniform" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__sample_unique_zipfian" t =
+     '[ '("range_max", AttrReq Int), '("shape", AttrOpt [Int])]
+
+__sample_unique_zipfian ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__sample_unique_zipfian" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__sample_unique_zipfian" t a -> TensorApply t
+__sample_unique_zipfian args
+  = let scalarArgs
+          = catMaybes
+              [("range_max",) . showValue <$> (args !? #range_max :: Maybe Int),
+               ("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_sample_unique_zipfian" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__scatter_elemwise_div" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__scatter_elemwise_div ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__scatter_elemwise_div" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__scatter_elemwise_div" t a -> TensorApply t
+__scatter_elemwise_div args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_scatter_elemwise_div" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__scatter_minus_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__scatter_minus_scalar ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "__scatter_minus_scalar" t a,
+                          HasCallStack) =>
+                         ArgsHMap "__scatter_minus_scalar" t a -> TensorApply t
+__scatter_minus_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_scatter_minus_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__scatter_plus_scalar" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+__scatter_plus_scalar ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__scatter_plus_scalar" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__scatter_plus_scalar" t a -> TensorApply t
+__scatter_plus_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_scatter_plus_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__scatter_set_nd" t =
+     '[ '("shape", AttrReq [Int]), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t), '("indices", AttrOpt t)]
+
+__scatter_set_nd ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__scatter_set_nd" t a, HasCallStack) =>
+                   ArgsHMap "__scatter_set_nd" t a -> TensorApply t
+__scatter_set_nd args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t),
+               ("indices",) <$> (args !? #indices :: Maybe t)]
+      in
+      apply "_scatter_set_nd" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__set_value" t =
+     '[ '("src", AttrOpt Float)]
+
+__set_value ::
+            forall a t .
+              (TensorOp t t, Fullfilled "__set_value" t a, HasCallStack) =>
+              ArgsHMap "__set_value" t a -> TensorApply t
+__set_value args
+  = let scalarArgs
+          = catMaybes
+              [("src",) . showValue <$> (args !? #src :: Maybe Float)]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_set_value" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__sg_mkldnn_conv" t = '[]
+
+__sg_mkldnn_conv ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "__sg_mkldnn_conv" t a, HasCallStack) =>
+                   ArgsHMap "__sg_mkldnn_conv" t a -> TensorApply t
+__sg_mkldnn_conv args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_sg_mkldnn_conv" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__sg_mkldnn_fully_connected" t = '[]
+
+__sg_mkldnn_fully_connected ::
+                            forall a t .
+                              (TensorOp t t, Fullfilled "__sg_mkldnn_fully_connected" t a,
+                               HasCallStack) =>
+                              ArgsHMap "__sg_mkldnn_fully_connected" t a -> TensorApply t
+__sg_mkldnn_fully_connected args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_sg_mkldnn_fully_connected" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__shuffle" t =
+     '[ '("data", AttrOpt t)]
+
+__shuffle ::
+          forall a t .
+            (TensorOp t t, Fullfilled "__shuffle" t a, HasCallStack) =>
+            ArgsHMap "__shuffle" t a -> TensorApply t
+__shuffle args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_shuffle" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__slice_assign" t =
+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
+        '("step", AttrOpt [Int]), '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+__slice_assign ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "__slice_assign" t a, HasCallStack) =>
+                 ArgsHMap "__slice_assign" t a -> TensorApply t
+__slice_assign args
+  = let scalarArgs
+          = catMaybes
+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "_slice_assign" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__slice_assign_scalar" t =
+     '[ '("scalar", AttrOpt Double), '("begin", AttrReq [Int]),
+        '("end", AttrReq [Int]), '("step", AttrOpt [Int]),
+        '("data", AttrOpt t)]
+
+__slice_assign_scalar ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__slice_assign_scalar" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__slice_assign_scalar" t a -> TensorApply t
+__slice_assign_scalar args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Double),
+               ("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_slice_assign_scalar" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__sparse_adagrad_update" t =
+     '[ '("lr", AttrReq Float), '("epsilon", AttrOpt Float),
+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("weight", AttrOpt t),
+        '("grad", AttrOpt t), '("history", AttrOpt t)]
+
+__sparse_adagrad_update ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "__sparse_adagrad_update" t a,
+                           HasCallStack) =>
+                          ArgsHMap "__sparse_adagrad_update" t a -> TensorApply t
+__sparse_adagrad_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("history",) <$> (args !? #history :: Maybe t)]
+      in
+      apply "_sparse_adagrad_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__sparse_retain" t =
+     '[ '("data", AttrOpt t), '("indices", AttrOpt t)]
+
+__sparse_retain ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__sparse_retain" t a, HasCallStack) =>
+                  ArgsHMap "__sparse_retain" t a -> TensorApply t
+__sparse_retain args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("indices",) <$> (args !? #indices :: Maybe t)]
+      in
+      apply "_sparse_retain" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__split_v2" t =
+     '[ '("indices", AttrReq [Int]), '("axis", AttrOpt Int),
+        '("squeeze_axis", AttrOpt Bool), '("sections", AttrOpt Int),
+        '("data", AttrOpt t)]
+
+__split_v2 ::
+           forall a t .
+             (TensorOp t t, Fullfilled "__split_v2" t a, HasCallStack) =>
+             ArgsHMap "__split_v2" t a -> TensorApply t
+__split_v2 args
+  = let scalarArgs
+          = catMaybes
+              [("indices",) . showValue <$> (args !? #indices :: Maybe [Int]),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe Int),
+               ("squeeze_axis",) . showValue <$>
+                 (args !? #squeeze_axis :: Maybe Bool),
+               ("sections",) . showValue <$> (args !? #sections :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_split_v2" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__split_v2_backward" t = '[]
+
+__split_v2_backward ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "__split_v2_backward" t a,
+                       HasCallStack) =>
+                      ArgsHMap "__split_v2_backward" t a -> TensorApply t
+__split_v2_backward args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_split_v2_backward" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__square_sum" t =
+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
+        '("exclude", AttrOpt Bool), '("data", AttrOpt t)]
+
+__square_sum ::
+             forall a t .
+               (TensorOp t t, Fullfilled "__square_sum" t a, HasCallStack) =>
+               ArgsHMap "__square_sum" t a -> TensorApply t
+__square_sum args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_square_sum" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__unravel_index" t =
+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt t)]
+
+__unravel_index ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "__unravel_index" t a, HasCallStack) =>
+                  ArgsHMap "__unravel_index" t a -> TensorApply t
+__unravel_index args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "_unravel_index" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__zeros" t =
+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt Text),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["bool", "float16", "float32", "float64", "int32", "int64",
+                 "int8", "uint8"]))]
+
+__zeros ::
+        forall a t .
+          (TensorOp t t, Fullfilled "__zeros" t a, HasCallStack) =>
+          ArgsHMap "__zeros" t a -> TensorApply t
+__zeros args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["bool", "float16", "float32", "float64", "int32", "int64",
+                           "int8", "uint8"]))]
+        tensorKeyArgs = catMaybes []
+      in apply "_zeros" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "__zeros_without_dtype" t =
+     '[ '("shape", AttrOpt [Int]), '("ctx", AttrOpt Text),
+        '("dtype", AttrOpt Int)]
+
+__zeros_without_dtype ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "__zeros_without_dtype" t a,
+                         HasCallStack) =>
+                        ArgsHMap "__zeros_without_dtype" t a -> TensorApply t
+__zeros_without_dtype args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int]),
+               ("ctx",) . showValue <$> (args !? #ctx :: Maybe Text),
+               ("dtype",) . showValue <$> (args !? #dtype :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+      in
+      apply "_zeros_without_dtype" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_abs" t = '[ '("data", AttrOpt t)]
+
+_abs ::
+     forall a t . (TensorOp t t, Fullfilled "_abs" t a, HasCallStack) =>
+       ArgsHMap "_abs" t a -> TensorApply t
+_abs args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "abs" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_adam_update" t =
+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Float),
+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
+        '("weight", AttrOpt t), '("grad", AttrOpt t), '("mean", AttrOpt t),
+        '("var", AttrOpt t)]
+
+_adam_update ::
+             forall a t .
+               (TensorOp t t, Fullfilled "_adam_update" t a, HasCallStack) =>
+               ArgsHMap "_adam_update" t a -> TensorApply t
+_adam_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("lazy_update",) . showValue <$>
+                 (args !? #lazy_update :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("mean",) <$> (args !? #mean :: Maybe t),
+               ("var",) <$> (args !? #var :: Maybe t)]
+      in
+      apply "adam_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_add_n" t = '[ '("args", AttrOpt [t])]
+
+_add_n ::
+       forall a t .
+         (TensorOp t t, Fullfilled "_add_n" t a, HasCallStack) =>
+         ArgsHMap "_add_n" t a -> TensorApply t
+_add_n args
+  = let scalarArgs
+          = catMaybes [Just ("num_args", showValue (length tensorVarArgs))]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #args :: Maybe [t])
+      in apply "add_n" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_all_finite" t =
+     '[ '("init_output", AttrOpt Bool), '("data", AttrOpt t)]
+
+_all_finite ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_all_finite" t a, HasCallStack) =>
+              ArgsHMap "_all_finite" t a -> TensorApply t
+_all_finite args
+  = let scalarArgs
+          = catMaybes
+              [("init_output",) . showValue <$>
+                 (args !? #init_output :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "all_finite" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_amp_cast" t =
+     '[ '("dtype",
+          AttrReq
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "int8",
+                 "uint8"])),
+        '("data", AttrOpt t)]
+
+_amp_cast ::
+          forall a t .
+            (TensorOp t t, Fullfilled "_amp_cast" t a, HasCallStack) =>
+            ArgsHMap "_amp_cast" t a -> TensorApply t
+_amp_cast args
+  = let scalarArgs
+          = catMaybes
+              [("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "int8",
+                           "uint8"]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "amp_cast" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_amp_multicast" t =
+     '[ '("num_outputs", AttrReq Int), '("cast_narrow", AttrOpt Bool),
+        '("data", AttrOpt [t])]
+
+_amp_multicast ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "_amp_multicast" t a, HasCallStack) =>
+                 ArgsHMap "_amp_multicast" t a -> TensorApply t
+_amp_multicast args
+  = let scalarArgs
+          = catMaybes
+              [("num_outputs",) . showValue <$>
+                 (args !? #num_outputs :: Maybe Int),
+               ("cast_narrow",) . showValue <$>
+                 (args !? #cast_narrow :: Maybe Bool)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "amp_multicast" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_arccos" t = '[ '("data", AttrOpt t)]
+
+_arccos ::
+        forall a t .
+          (TensorOp t t, Fullfilled "_arccos" t a, HasCallStack) =>
+          ArgsHMap "_arccos" t a -> TensorApply t
+_arccos args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "arccos" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_arccosh" t = '[ '("data", AttrOpt t)]
+
+_arccosh ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_arccosh" t a, HasCallStack) =>
+           ArgsHMap "_arccosh" t a -> TensorApply t
+_arccosh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "arccosh" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_arcsin" t = '[ '("data", AttrOpt t)]
+
+_arcsin ::
+        forall a t .
+          (TensorOp t t, Fullfilled "_arcsin" t a, HasCallStack) =>
+          ArgsHMap "_arcsin" t a -> TensorApply t
+_arcsin args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "arcsin" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_arcsinh" t = '[ '("data", AttrOpt t)]
+
+_arcsinh ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_arcsinh" t a, HasCallStack) =>
+           ArgsHMap "_arcsinh" t a -> TensorApply t
+_arcsinh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "arcsinh" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_arctan" t = '[ '("data", AttrOpt t)]
+
+_arctan ::
+        forall a t .
+          (TensorOp t t, Fullfilled "_arctan" t a, HasCallStack) =>
+          ArgsHMap "_arctan" t a -> TensorApply t
+_arctan args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "arctan" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_arctanh" t = '[ '("data", AttrOpt t)]
+
+_arctanh ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_arctanh" t a, HasCallStack) =>
+           ArgsHMap "_arctanh" t a -> TensorApply t
+_arctanh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "arctanh" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_argmax" t =
+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
+        '("data", AttrOpt t)]
+
+_argmax ::
+        forall a t .
+          (TensorOp t t, Fullfilled "_argmax" t a, HasCallStack) =>
+          ArgsHMap "_argmax" t a -> TensorApply t
+_argmax args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "argmax" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_argmax_channel" t =
+     '[ '("data", AttrOpt t)]
+
+_argmax_channel ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "_argmax_channel" t a, HasCallStack) =>
+                  ArgsHMap "_argmax_channel" t a -> TensorApply t
+_argmax_channel args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "argmax_channel" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_argmin" t =
+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
+        '("data", AttrOpt t)]
+
+_argmin ::
+        forall a t .
+          (TensorOp t t, Fullfilled "_argmin" t a, HasCallStack) =>
+          ArgsHMap "_argmin" t a -> TensorApply t
+_argmin args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "argmin" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_argsort" t =
+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "uint8"])),
+        '("data", AttrOpt t)]
+
+_argsort ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_argsort" t a, HasCallStack) =>
+           ArgsHMap "_argsort" t a -> TensorApply t
+_argsort args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "uint8"]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "argsort" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_batch_dot" t =
+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
+        '("forward_stype",
+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),
+        '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_batch_dot ::
+           forall a t .
+             (TensorOp t t, Fullfilled "_batch_dot" t a, HasCallStack) =>
+             ArgsHMap "_batch_dot" t a -> TensorApply t
+_batch_dot args
+  = let scalarArgs
+          = catMaybes
+              [("transpose_a",) . showValue <$>
+                 (args !? #transpose_a :: Maybe Bool),
+               ("transpose_b",) . showValue <$>
+                 (args !? #transpose_b :: Maybe Bool),
+               ("forward_stype",) . showValue <$>
+                 (args !? #forward_stype ::
+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "batch_dot" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_batch_take" t =
+     '[ '("a", AttrOpt t), '("indices", AttrOpt t)]
+
+_batch_take ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_batch_take" t a, HasCallStack) =>
+              ArgsHMap "_batch_take" t a -> TensorApply t
+_batch_take args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("a",) <$> (args !? #a :: Maybe t),
+               ("indices",) <$> (args !? #indices :: Maybe t)]
+      in
+      apply "batch_take" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_add" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_add ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "_broadcast_add" t a, HasCallStack) =>
+                 ArgsHMap "_broadcast_add" t a -> TensorApply t
+_broadcast_add args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_add" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_axis" t =
+     '[ '("axis", AttrOpt [Int]), '("size", AttrOpt [Int]),
+        '("data", AttrOpt t)]
+
+_broadcast_axis ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "_broadcast_axis" t a, HasCallStack) =>
+                  ArgsHMap "_broadcast_axis" t a -> TensorApply t
+_broadcast_axis args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int]),
+               ("size",) . showValue <$> (args !? #size :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "broadcast_axis" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_div" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_div ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "_broadcast_div" t a, HasCallStack) =>
+                 ArgsHMap "_broadcast_div" t a -> TensorApply t
+_broadcast_div args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_div" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_equal" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_equal ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "_broadcast_equal" t a, HasCallStack) =>
+                   ArgsHMap "_broadcast_equal" t a -> TensorApply t
+_broadcast_equal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_equal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_greater" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_greater ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "_broadcast_greater" t a,
+                      HasCallStack) =>
+                     ArgsHMap "_broadcast_greater" t a -> TensorApply t
+_broadcast_greater args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_greater" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_greater_equal" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_greater_equal ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "_broadcast_greater_equal" t a,
+                            HasCallStack) =>
+                           ArgsHMap "_broadcast_greater_equal" t a -> TensorApply t
+_broadcast_greater_equal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_greater_equal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_hypot" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_hypot ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "_broadcast_hypot" t a, HasCallStack) =>
+                   ArgsHMap "_broadcast_hypot" t a -> TensorApply t
+_broadcast_hypot args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_hypot" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_lesser" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_lesser ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "_broadcast_lesser" t a, HasCallStack) =>
+                    ArgsHMap "_broadcast_lesser" t a -> TensorApply t
+_broadcast_lesser args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_lesser" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_lesser_equal" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_lesser_equal ::
+                        forall a t .
+                          (TensorOp t t, Fullfilled "_broadcast_lesser_equal" t a,
+                           HasCallStack) =>
+                          ArgsHMap "_broadcast_lesser_equal" t a -> TensorApply t
+_broadcast_lesser_equal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_lesser_equal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_like" t =
+     '[ '("lhs_axes", AttrOpt (Maybe [Int])),
+        '("rhs_axes", AttrOpt (Maybe [Int])), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t)]
+
+_broadcast_like ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "_broadcast_like" t a, HasCallStack) =>
+                  ArgsHMap "_broadcast_like" t a -> TensorApply t
+_broadcast_like args
+  = let scalarArgs
+          = catMaybes
+              [("lhs_axes",) . showValue <$>
+                 (args !? #lhs_axes :: Maybe (Maybe [Int])),
+               ("rhs_axes",) . showValue <$>
+                 (args !? #rhs_axes :: Maybe (Maybe [Int]))]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_like" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_logical_and" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_logical_and ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "_broadcast_logical_and" t a,
+                          HasCallStack) =>
+                         ArgsHMap "_broadcast_logical_and" t a -> TensorApply t
+_broadcast_logical_and args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_logical_and" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_logical_or" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_logical_or ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "_broadcast_logical_or" t a,
+                         HasCallStack) =>
+                        ArgsHMap "_broadcast_logical_or" t a -> TensorApply t
+_broadcast_logical_or args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_logical_or" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_logical_xor" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_logical_xor ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "_broadcast_logical_xor" t a,
+                          HasCallStack) =>
+                         ArgsHMap "_broadcast_logical_xor" t a -> TensorApply t
+_broadcast_logical_xor args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_logical_xor" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_maximum" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_maximum ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "_broadcast_maximum" t a,
+                      HasCallStack) =>
+                     ArgsHMap "_broadcast_maximum" t a -> TensorApply t
+_broadcast_maximum args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_maximum" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_minimum" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_minimum ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "_broadcast_minimum" t a,
+                      HasCallStack) =>
+                     ArgsHMap "_broadcast_minimum" t a -> TensorApply t
+_broadcast_minimum args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_minimum" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_mod" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_mod ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "_broadcast_mod" t a, HasCallStack) =>
+                 ArgsHMap "_broadcast_mod" t a -> TensorApply t
+_broadcast_mod args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_mod" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_mul" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_mul ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "_broadcast_mul" t a, HasCallStack) =>
+                 ArgsHMap "_broadcast_mul" t a -> TensorApply t
+_broadcast_mul args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_mul" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_not_equal" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_not_equal ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "_broadcast_not_equal" t a,
+                        HasCallStack) =>
+                       ArgsHMap "_broadcast_not_equal" t a -> TensorApply t
+_broadcast_not_equal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_not_equal" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_power" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_power ::
+                 forall a t .
+                   (TensorOp t t, Fullfilled "_broadcast_power" t a, HasCallStack) =>
+                   ArgsHMap "_broadcast_power" t a -> TensorApply t
+_broadcast_power args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_power" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_sub" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_broadcast_sub ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "_broadcast_sub" t a, HasCallStack) =>
+                 ArgsHMap "_broadcast_sub" t a -> TensorApply t
+_broadcast_sub args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "broadcast_sub" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_broadcast_to" t =
+     '[ '("shape", AttrOpt [Int]), '("data", AttrOpt t)]
+
+_broadcast_to ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_broadcast_to" t a, HasCallStack) =>
+                ArgsHMap "_broadcast_to" t a -> TensorApply t
+_broadcast_to args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "broadcast_to" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_cast_storage" t =
+     '[ '("stype",
+          AttrReq (EnumType '["csr", "default", "row_sparse"])),
+        '("data", AttrOpt t)]
+
+_cast_storage ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_cast_storage" t a, HasCallStack) =>
+                ArgsHMap "_cast_storage" t a -> TensorApply t
+_cast_storage args
+  = let scalarArgs
+          = catMaybes
+              [("stype",) . showValue <$>
+                 (args !? #stype ::
+                    Maybe (EnumType '["csr", "default", "row_sparse"]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "cast_storage" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_cbrt" t = '[ '("data", AttrOpt t)]
+
+_cbrt ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_cbrt" t a, HasCallStack) =>
+        ArgsHMap "_cbrt" t a -> TensorApply t
+_cbrt args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "cbrt" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_ceil" t = '[ '("data", AttrOpt t)]
+
+_ceil ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_ceil" t a, HasCallStack) =>
+        ArgsHMap "_ceil" t a -> TensorApply t
+_ceil args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "ceil" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_clip" t =
+     '[ '("a_min", AttrReq Float), '("a_max", AttrReq Float),
+        '("data", AttrOpt t)]
+
+_clip ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_clip" t a, HasCallStack) =>
+        ArgsHMap "_clip" t a -> TensorApply t
+_clip args
+  = let scalarArgs
+          = catMaybes
+              [("a_min",) . showValue <$> (args !? #a_min :: Maybe Float),
+               ("a_max",) . showValue <$> (args !? #a_max :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "clip" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_cos" t = '[ '("data", AttrOpt t)]
+
+_cos ::
+     forall a t . (TensorOp t t, Fullfilled "_cos" t a, HasCallStack) =>
+       ArgsHMap "_cos" t a -> TensorApply t
+_cos args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "cos" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_cosh" t = '[ '("data", AttrOpt t)]
+
+_cosh ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_cosh" t a, HasCallStack) =>
+        ArgsHMap "_cosh" t a -> TensorApply t
+_cosh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "cosh" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_degrees" t = '[ '("data", AttrOpt t)]
+
+_degrees ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_degrees" t a, HasCallStack) =>
+           ArgsHMap "_degrees" t a -> TensorApply t
+_degrees args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "degrees" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_depth_to_space" t =
+     '[ '("block_size", AttrReq Int), '("data", AttrOpt t)]
+
+_depth_to_space ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "_depth_to_space" t a, HasCallStack) =>
+                  ArgsHMap "_depth_to_space" t a -> TensorApply t
+_depth_to_space args
+  = let scalarArgs
+          = catMaybes
+              [("block_size",) . showValue <$>
+                 (args !? #block_size :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "depth_to_space" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_diag" t =
+     '[ '("k", AttrOpt Int), '("axis1", AttrOpt Int),
+        '("axis2", AttrOpt Int), '("data", AttrOpt t)]
+
+_diag ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_diag" t a, HasCallStack) =>
+        ArgsHMap "_diag" t a -> TensorApply t
+_diag args
+  = let scalarArgs
+          = catMaybes
+              [("k",) . showValue <$> (args !? #k :: Maybe Int),
+               ("axis1",) . showValue <$> (args !? #axis1 :: Maybe Int),
+               ("axis2",) . showValue <$> (args !? #axis2 :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "diag" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_dot" t =
+     '[ '("transpose_a", AttrOpt Bool), '("transpose_b", AttrOpt Bool),
+        '("forward_stype",
+          AttrOpt (Maybe (EnumType '["csr", "default", "row_sparse"]))),
+        '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_dot ::
+     forall a t . (TensorOp t t, Fullfilled "_dot" t a, HasCallStack) =>
+       ArgsHMap "_dot" t a -> TensorApply t
+_dot args
+  = let scalarArgs
+          = catMaybes
+              [("transpose_a",) . showValue <$>
+                 (args !? #transpose_a :: Maybe Bool),
+               ("transpose_b",) . showValue <$>
+                 (args !? #transpose_b :: Maybe Bool),
+               ("forward_stype",) . showValue <$>
+                 (args !? #forward_stype ::
+                    Maybe (Maybe (EnumType '["csr", "default", "row_sparse"])))]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in apply "dot" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_elemwise_add" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_elemwise_add ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_elemwise_add" t a, HasCallStack) =>
+                ArgsHMap "_elemwise_add" t a -> TensorApply t
+_elemwise_add args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "elemwise_add" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_elemwise_div" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_elemwise_div ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_elemwise_div" t a, HasCallStack) =>
+                ArgsHMap "_elemwise_div" t a -> TensorApply t
+_elemwise_div args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "elemwise_div" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_elemwise_mul" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_elemwise_mul ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_elemwise_mul" t a, HasCallStack) =>
+                ArgsHMap "_elemwise_mul" t a -> TensorApply t
+_elemwise_mul args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "elemwise_mul" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_elemwise_sub" t =
+     '[ '("lhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_elemwise_sub ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_elemwise_sub" t a, HasCallStack) =>
+                ArgsHMap "_elemwise_sub" t a -> TensorApply t
+_elemwise_sub args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "elemwise_sub" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_erf" t = '[ '("data", AttrOpt t)]
+
+_erf ::
+     forall a t . (TensorOp t t, Fullfilled "_erf" t a, HasCallStack) =>
+       ArgsHMap "_erf" t a -> TensorApply t
+_erf args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "erf" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_erfinv" t = '[ '("data", AttrOpt t)]
+
+_erfinv ::
+        forall a t .
+          (TensorOp t t, Fullfilled "_erfinv" t a, HasCallStack) =>
+          ArgsHMap "_erfinv" t a -> TensorApply t
+_erfinv args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "erfinv" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_exp" t = '[ '("data", AttrOpt t)]
+
+_exp ::
+     forall a t . (TensorOp t t, Fullfilled "_exp" t a, HasCallStack) =>
+       ArgsHMap "_exp" t a -> TensorApply t
+_exp args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "exp" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_expand_dims" t =
+     '[ '("axis", AttrReq Int), '("data", AttrOpt t)]
+
+_expand_dims ::
+             forall a t .
+               (TensorOp t t, Fullfilled "_expand_dims" t a, HasCallStack) =>
+               ArgsHMap "_expand_dims" t a -> TensorApply t
+_expand_dims args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "expand_dims" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_expm1" t = '[ '("data", AttrOpt t)]
+
+_expm1 ::
+       forall a t .
+         (TensorOp t t, Fullfilled "_expm1" t a, HasCallStack) =>
+         ArgsHMap "_expm1" t a -> TensorApply t
+_expm1 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "expm1" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_fill_element_0index" t =
+     '[ '("lhs", AttrOpt t), '("mhs", AttrOpt t), '("rhs", AttrOpt t)]
+
+_fill_element_0index ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "_fill_element_0index" t a,
+                        HasCallStack) =>
+                       ArgsHMap "_fill_element_0index" t a -> TensorApply t
+_fill_element_0index args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("mhs",) <$> (args !? #mhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "fill_element_0index" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_fix" t = '[ '("data", AttrOpt t)]
+
+_fix ::
+     forall a t . (TensorOp t t, Fullfilled "_fix" t a, HasCallStack) =>
+       ArgsHMap "_fix" t a -> TensorApply t
+_fix args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "fix" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_floor" t = '[ '("data", AttrOpt t)]
+
+_floor ::
+       forall a t .
+         (TensorOp t t, Fullfilled "_floor" t a, HasCallStack) =>
+         ArgsHMap "_floor" t a -> TensorApply t
+_floor args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "floor" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_ftml_update" t =
+     '[ '("lr", AttrReq Float), '("beta1", AttrOpt Float),
+        '("beta2", AttrOpt Float), '("epsilon", AttrOpt Double),
+        '("t", AttrReq Int), '("wd", AttrOpt Float),
+        '("rescale_grad", AttrOpt Float), '("clip_grad", AttrOpt Float),
+        '("weight", AttrOpt t), '("grad", AttrOpt t), '("d", AttrOpt t),
+        '("v", AttrOpt t), '("z", AttrOpt t)]
+
+_ftml_update ::
+             forall a t .
+               (TensorOp t t, Fullfilled "_ftml_update" t a, HasCallStack) =>
+               ArgsHMap "_ftml_update" t a -> TensorApply t
+_ftml_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Double),
+               ("t",) . showValue <$> (args !? #t :: Maybe Int),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_grad",) . showValue <$> (args !? #clip_grad :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("d",) <$> (args !? #d :: Maybe t),
+               ("v",) <$> (args !? #v :: Maybe t),
+               ("z",) <$> (args !? #z :: Maybe t)]
+      in
+      apply "ftml_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_ftrl_update" t =
+     '[ '("lr", AttrReq Float), '("lamda1", AttrOpt Float),
+        '("beta", AttrOpt Float), '("wd", AttrOpt Float),
+        '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("weight", AttrOpt t),
+        '("grad", AttrOpt t), '("z", AttrOpt t), '("n", AttrOpt t)]
+
+_ftrl_update ::
+             forall a t .
+               (TensorOp t t, Fullfilled "_ftrl_update" t a, HasCallStack) =>
+               ArgsHMap "_ftrl_update" t a -> TensorApply t
+_ftrl_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("lamda1",) . showValue <$> (args !? #lamda1 :: Maybe Float),
+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("z",) <$> (args !? #z :: Maybe t),
+               ("n",) <$> (args !? #n :: Maybe t)]
+      in
+      apply "ftrl_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_gamma" t = '[ '("data", AttrOpt t)]
+
+_gamma ::
+       forall a t .
+         (TensorOp t t, Fullfilled "_gamma" t a, HasCallStack) =>
+         ArgsHMap "_gamma" t a -> TensorApply t
+_gamma args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "gamma" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_gammaln" t = '[ '("data", AttrOpt t)]
+
+_gammaln ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_gammaln" t a, HasCallStack) =>
+           ArgsHMap "_gammaln" t a -> TensorApply t
+_gammaln args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "gammaln" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_gather_nd" t =
+     '[ '("data", AttrOpt t), '("indices", AttrOpt t)]
+
+_gather_nd ::
+           forall a t .
+             (TensorOp t t, Fullfilled "_gather_nd" t a, HasCallStack) =>
+             ArgsHMap "_gather_nd" t a -> TensorApply t
+_gather_nd args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("indices",) <$> (args !? #indices :: Maybe t)]
+      in
+      apply "gather_nd" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_hard_sigmoid" t =
+     '[ '("alpha", AttrOpt Float), '("beta", AttrOpt Float),
+        '("data", AttrOpt t)]
+
+_hard_sigmoid ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_hard_sigmoid" t a, HasCallStack) =>
+                ArgsHMap "_hard_sigmoid" t a -> TensorApply t
+_hard_sigmoid args
+  = let scalarArgs
+          = catMaybes
+              [("alpha",) . showValue <$> (args !? #alpha :: Maybe Float),
+               ("beta",) . showValue <$> (args !? #beta :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "hard_sigmoid" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_khatri_rao" t =
+     '[ '("args", AttrOpt [t])]
+
+_khatri_rao ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_khatri_rao" t a, HasCallStack) =>
+              ArgsHMap "_khatri_rao" t a -> TensorApply t
+_khatri_rao args
+  = let scalarArgs
+          = catMaybes [Just ("num_args", showValue (length tensorVarArgs))]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #args :: Maybe [t])
+      in apply "khatri_rao" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_lamb_update_phase1" t =
+     '[ '("beta1", AttrOpt Float), '("beta2", AttrOpt Float),
+        '("epsilon", AttrOpt Float), '("t", AttrReq Int),
+        '("bias_correction", AttrOpt Bool), '("wd", AttrReq Float),
+        '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("weight", AttrOpt t),
+        '("grad", AttrOpt t), '("mean", AttrOpt t), '("var", AttrOpt t)]
+
+_lamb_update_phase1 ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "_lamb_update_phase1" t a,
+                       HasCallStack) =>
+                      ArgsHMap "_lamb_update_phase1" t a -> TensorApply t
+_lamb_update_phase1 args
+  = let scalarArgs
+          = catMaybes
+              [("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
+               ("t",) . showValue <$> (args !? #t :: Maybe Int),
+               ("bias_correction",) . showValue <$>
+                 (args !? #bias_correction :: Maybe Bool),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("mean",) <$> (args !? #mean :: Maybe t),
+               ("var",) <$> (args !? #var :: Maybe t)]
+      in
+      apply "lamb_update_phase1" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_lamb_update_phase2" t =
+     '[ '("lr", AttrReq Float), '("lower_bound", AttrOpt Float),
+        '("upper_bound", AttrOpt Float), '("weight", AttrOpt t),
+        '("g", AttrOpt t), '("r1", AttrOpt t), '("r2", AttrOpt t)]
+
+_lamb_update_phase2 ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "_lamb_update_phase2" t a,
+                       HasCallStack) =>
+                      ArgsHMap "_lamb_update_phase2" t a -> TensorApply t
+_lamb_update_phase2 args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("lower_bound",) . showValue <$>
+                 (args !? #lower_bound :: Maybe Float),
+               ("upper_bound",) . showValue <$>
+                 (args !? #upper_bound :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("g",) <$> (args !? #g :: Maybe t),
+               ("r1",) <$> (args !? #r1 :: Maybe t),
+               ("r2",) <$> (args !? #r2 :: Maybe t)]
+      in
+      apply "lamb_update_phase2" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_log" t = '[ '("data", AttrOpt t)]
+
+_log ::
+     forall a t . (TensorOp t t, Fullfilled "_log" t a, HasCallStack) =>
+       ArgsHMap "_log" t a -> TensorApply t
+_log args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "log" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_log10" t = '[ '("data", AttrOpt t)]
+
+_log10 ::
+       forall a t .
+         (TensorOp t t, Fullfilled "_log10" t a, HasCallStack) =>
+         ArgsHMap "_log10" t a -> TensorApply t
+_log10 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "log10" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_log1p" t = '[ '("data", AttrOpt t)]
+
+_log1p ::
+       forall a t .
+         (TensorOp t t, Fullfilled "_log1p" t a, HasCallStack) =>
+         ArgsHMap "_log1p" t a -> TensorApply t
+_log1p args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "log1p" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_log2" t = '[ '("data", AttrOpt t)]
+
+_log2 ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_log2" t a, HasCallStack) =>
+        ArgsHMap "_log2" t a -> TensorApply t
+_log2 args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "log2" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_log_softmax" t =
+     '[ '("axis", AttrOpt Int),
+        '("temperature", AttrOpt (Maybe Double)),
+        '("dtype",
+          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),
+        '("use_length", AttrOpt (Maybe Bool)), '("data", AttrOpt t)]
+
+_log_softmax ::
+             forall a t .
+               (TensorOp t t, Fullfilled "_log_softmax" t a, HasCallStack) =>
+               ArgsHMap "_log_softmax" t a -> TensorApply t
+_log_softmax args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
+               ("temperature",) . showValue <$>
+                 (args !? #temperature :: Maybe (Maybe Double)),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (Maybe (EnumType '["float16", "float32", "float64"]))),
+               ("use_length",) . showValue <$>
+                 (args !? #use_length :: Maybe (Maybe Bool))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "log_softmax" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_logical_not" t =
+     '[ '("data", AttrOpt t)]
+
+_logical_not ::
+             forall a t .
+               (TensorOp t t, Fullfilled "_logical_not" t a, HasCallStack) =>
+               ArgsHMap "_logical_not" t a -> TensorApply t
+_logical_not args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "logical_not" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_make_loss" t =
+     '[ '("data", AttrOpt t)]
+
+_make_loss ::
+           forall a t .
+             (TensorOp t t, Fullfilled "_make_loss" t a, HasCallStack) =>
+             ArgsHMap "_make_loss" t a -> TensorApply t
+_make_loss args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "make_loss" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_max" t =
+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
+        '("exclude", AttrOpt Bool), '("data", AttrOpt t)]
+
+_max ::
+     forall a t . (TensorOp t t, Fullfilled "_max" t a, HasCallStack) =>
+       ArgsHMap "_max" t a -> TensorApply t
+_max args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "max" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_mean" t =
+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
+        '("exclude", AttrOpt Bool), '("data", AttrOpt t)]
+
+_mean ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_mean" t a, HasCallStack) =>
+        ArgsHMap "_mean" t a -> TensorApply t
+_mean args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "mean" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_min" t =
+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
+        '("exclude", AttrOpt Bool), '("data", AttrOpt t)]
+
+_min ::
+     forall a t . (TensorOp t t, Fullfilled "_min" t a, HasCallStack) =>
+       ArgsHMap "_min" t a -> TensorApply t
+_min args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "min" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_moments" t =
+     '[ '("axes", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
+        '("data", AttrOpt t)]
+
+_moments ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_moments" t a, HasCallStack) =>
+           ArgsHMap "_moments" t a -> TensorApply t
+_moments args
+  = let scalarArgs
+          = catMaybes
+              [("axes",) . showValue <$> (args !? #axes :: Maybe (Maybe [Int])),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "moments" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_mp_lamb_update_phase1" t =
+     '[ '("beta1", AttrOpt Float), '("beta2", AttrOpt Float),
+        '("epsilon", AttrOpt Float), '("t", AttrReq Int),
+        '("bias_correction", AttrOpt Bool), '("wd", AttrReq Float),
+        '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("weight", AttrOpt t),
+        '("grad", AttrOpt t), '("mean", AttrOpt t), '("var", AttrOpt t),
+        '("weight32", AttrOpt t)]
+
+_mp_lamb_update_phase1 ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "_mp_lamb_update_phase1" t a,
+                          HasCallStack) =>
+                         ArgsHMap "_mp_lamb_update_phase1" t a -> TensorApply t
+_mp_lamb_update_phase1 args
+  = let scalarArgs
+          = catMaybes
+              [("beta1",) . showValue <$> (args !? #beta1 :: Maybe Float),
+               ("beta2",) . showValue <$> (args !? #beta2 :: Maybe Float),
+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
+               ("t",) . showValue <$> (args !? #t :: Maybe Int),
+               ("bias_correction",) . showValue <$>
+                 (args !? #bias_correction :: Maybe Bool),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("mean",) <$> (args !? #mean :: Maybe t),
+               ("var",) <$> (args !? #var :: Maybe t),
+               ("weight32",) <$> (args !? #weight32 :: Maybe t)]
+      in
+      apply "mp_lamb_update_phase1" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_mp_lamb_update_phase2" t =
+     '[ '("lr", AttrReq Float), '("lower_bound", AttrOpt Float),
+        '("upper_bound", AttrOpt Float), '("weight", AttrOpt t),
+        '("g", AttrOpt t), '("r1", AttrOpt t), '("r2", AttrOpt t),
+        '("weight32", AttrOpt t)]
+
+_mp_lamb_update_phase2 ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "_mp_lamb_update_phase2" t a,
+                          HasCallStack) =>
+                         ArgsHMap "_mp_lamb_update_phase2" t a -> TensorApply t
+_mp_lamb_update_phase2 args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("lower_bound",) . showValue <$>
+                 (args !? #lower_bound :: Maybe Float),
+               ("upper_bound",) . showValue <$>
+                 (args !? #upper_bound :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("g",) <$> (args !? #g :: Maybe t),
+               ("r1",) <$> (args !? #r1 :: Maybe t),
+               ("r2",) <$> (args !? #r2 :: Maybe t),
+               ("weight32",) <$> (args !? #weight32 :: Maybe t)]
+      in
+      apply "mp_lamb_update_phase2" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_mp_nag_mom_update" t =
+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("weight", AttrOpt t),
+        '("grad", AttrOpt t), '("mom", AttrOpt t),
+        '("weight32", AttrOpt t)]
+
+_mp_nag_mom_update ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "_mp_nag_mom_update" t a,
+                      HasCallStack) =>
+                     ArgsHMap "_mp_nag_mom_update" t a -> TensorApply t
+_mp_nag_mom_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("mom",) <$> (args !? #mom :: Maybe t),
+               ("weight32",) <$> (args !? #weight32 :: Maybe t)]
+      in
+      apply "mp_nag_mom_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_mp_sgd_mom_update" t =
+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
+        '("weight", AttrOpt t), '("grad", AttrOpt t), '("mom", AttrOpt t),
+        '("weight32", AttrOpt t)]
+
+_mp_sgd_mom_update ::
+                   forall a t .
+                     (TensorOp t t, Fullfilled "_mp_sgd_mom_update" t a,
+                      HasCallStack) =>
+                     ArgsHMap "_mp_sgd_mom_update" t a -> TensorApply t
+_mp_sgd_mom_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("lazy_update",) . showValue <$>
+                 (args !? #lazy_update :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("mom",) <$> (args !? #mom :: Maybe t),
+               ("weight32",) <$> (args !? #weight32 :: Maybe t)]
+      in
+      apply "mp_sgd_mom_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_mp_sgd_update" t =
+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
+        '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
+        '("weight", AttrOpt t), '("grad", AttrOpt t),
+        '("weight32", AttrOpt t)]
+
+_mp_sgd_update ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "_mp_sgd_update" t a, HasCallStack) =>
+                 ArgsHMap "_mp_sgd_update" t a -> TensorApply t
+_mp_sgd_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("lazy_update",) . showValue <$>
+                 (args !? #lazy_update :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("weight32",) <$> (args !? #weight32 :: Maybe t)]
+      in
+      apply "mp_sgd_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_multi_all_finite" t =
+     '[ '("num_arrays", AttrOpt Int), '("init_output", AttrOpt Bool),
+        '("data", AttrOpt [t])]
+
+_multi_all_finite ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "_multi_all_finite" t a, HasCallStack) =>
+                    ArgsHMap "_multi_all_finite" t a -> TensorApply t
+_multi_all_finite args
+  = let scalarArgs
+          = catMaybes
+              [("num_arrays",) . showValue <$>
+                 (args !? #num_arrays :: Maybe Int),
+               ("init_output",) . showValue <$>
+                 (args !? #init_output :: Maybe Bool)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "multi_all_finite" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_multi_lars" t =
+     '[ '("eta", AttrReq Float), '("eps", AttrReq Float),
+        '("rescale_grad", AttrOpt Float), '("lrs", AttrOpt t),
+        '("weights_sum_sq", AttrOpt t), '("grads_sum_sq", AttrOpt t),
+        '("wds", AttrOpt t)]
+
+_multi_lars ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_multi_lars" t a, HasCallStack) =>
+              ArgsHMap "_multi_lars" t a -> TensorApply t
+_multi_lars args
+  = let scalarArgs
+          = catMaybes
+              [("eta",) . showValue <$> (args !? #eta :: Maybe Float),
+               ("eps",) . showValue <$> (args !? #eps :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("lrs",) <$> (args !? #lrs :: Maybe t),
+               ("weights_sum_sq",) <$> (args !? #weights_sum_sq :: Maybe t),
+               ("grads_sum_sq",) <$> (args !? #grads_sum_sq :: Maybe t),
+               ("wds",) <$> (args !? #wds :: Maybe t)]
+      in
+      apply "multi_lars" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_multi_mp_sgd_mom_update" t =
+     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),
+        '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+_multi_mp_sgd_mom_update ::
+                         forall a t .
+                           (TensorOp t t, Fullfilled "_multi_mp_sgd_mom_update" t a,
+                            HasCallStack) =>
+                           ArgsHMap "_multi_mp_sgd_mom_update" t a -> TensorApply t
+_multi_mp_sgd_mom_update args
+  = let scalarArgs
+          = catMaybes
+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("num_weights",) . showValue <$>
+                 (args !? #num_weights :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "multi_mp_sgd_mom_update" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_multi_mp_sgd_update" t =
+     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),
+        '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+_multi_mp_sgd_update ::
+                     forall a t .
+                       (TensorOp t t, Fullfilled "_multi_mp_sgd_update" t a,
+                        HasCallStack) =>
+                       ArgsHMap "_multi_mp_sgd_update" t a -> TensorApply t
+_multi_mp_sgd_update args
+  = let scalarArgs
+          = catMaybes
+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("num_weights",) . showValue <$>
+                 (args !? #num_weights :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "multi_mp_sgd_update" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_multi_sgd_mom_update" t =
+     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),
+        '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+_multi_sgd_mom_update ::
+                      forall a t .
+                        (TensorOp t t, Fullfilled "_multi_sgd_mom_update" t a,
+                         HasCallStack) =>
+                        ArgsHMap "_multi_sgd_mom_update" t a -> TensorApply t
+_multi_sgd_mom_update args
+  = let scalarArgs
+          = catMaybes
+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("num_weights",) . showValue <$>
+                 (args !? #num_weights :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "multi_sgd_mom_update" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_multi_sgd_update" t =
+     '[ '("lrs", AttrReq [Float]), '("wds", AttrReq [Float]),
+        '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+_multi_sgd_update ::
+                  forall a t .
+                    (TensorOp t t, Fullfilled "_multi_sgd_update" t a, HasCallStack) =>
+                    ArgsHMap "_multi_sgd_update" t a -> TensorApply t
+_multi_sgd_update args
+  = let scalarArgs
+          = catMaybes
+              [("lrs",) . showValue <$> (args !? #lrs :: Maybe [Float]),
+               ("wds",) . showValue <$> (args !? #wds :: Maybe [Float]),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("num_weights",) . showValue <$>
+                 (args !? #num_weights :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "multi_sgd_update" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_multi_sum_sq" t =
+     '[ '("num_arrays", AttrReq Int), '("data", AttrOpt [t])]
+
+_multi_sum_sq ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_multi_sum_sq" t a, HasCallStack) =>
+                ArgsHMap "_multi_sum_sq" t a -> TensorApply t
+_multi_sum_sq args
+  = let scalarArgs
+          = catMaybes
+              [("num_arrays",) . showValue <$>
+                 (args !? #num_arrays :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "multi_sum_sq" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_nag_mom_update" t =
+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("weight", AttrOpt t),
+        '("grad", AttrOpt t), '("mom", AttrOpt t)]
+
+_nag_mom_update ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "_nag_mom_update" t a, HasCallStack) =>
+                  ArgsHMap "_nag_mom_update" t a -> TensorApply t
+_nag_mom_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("mom",) <$> (args !? #mom :: Maybe t)]
+      in
+      apply "nag_mom_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_nanprod" t =
+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
+        '("exclude", AttrOpt Bool), '("data", AttrOpt t)]
+
+_nanprod ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_nanprod" t a, HasCallStack) =>
+           ArgsHMap "_nanprod" t a -> TensorApply t
+_nanprod args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "nanprod" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_nansum" t =
+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
+        '("exclude", AttrOpt Bool), '("data", AttrOpt t)]
+
+_nansum ::
+        forall a t .
+          (TensorOp t t, Fullfilled "_nansum" t a, HasCallStack) =>
+          ArgsHMap "_nansum" t a -> TensorApply t
+_nansum args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "nansum" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_negative" t =
+     '[ '("data", AttrOpt t)]
+
+_negative ::
+          forall a t .
+            (TensorOp t t, Fullfilled "_negative" t a, HasCallStack) =>
+            ArgsHMap "_negative" t a -> TensorApply t
+_negative args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "negative" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_norm" t =
+     '[ '("ord", AttrOpt Int), '("axis", AttrOpt (Maybe [Int])),
+        '("out_dtype",
+          AttrOpt
+            (Maybe
+               (EnumType
+                  '["float16", "float32", "float64", "int32", "int64", "int8"]))),
+        '("keepdims", AttrOpt Bool), '("data", AttrOpt t)]
+
+_norm ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_norm" t a, HasCallStack) =>
+        ArgsHMap "_norm" t a -> TensorApply t
+_norm args
+  = let scalarArgs
+          = catMaybes
+              [("ord",) . showValue <$> (args !? #ord :: Maybe Int),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("out_dtype",) . showValue <$>
+                 (args !? #out_dtype ::
+                    Maybe
+                      (Maybe
+                         (EnumType
+                            '["float16", "float32", "float64", "int32", "int64", "int8"]))),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "norm" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_one_hot" t =
+     '[ '("depth", AttrReq Int), '("on_value", AttrOpt Double),
+        '("off_value", AttrOpt Double),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "int8",
+                 "uint8"])),
+        '("indices", AttrOpt t)]
+
+_one_hot ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_one_hot" t a, HasCallStack) =>
+           ArgsHMap "_one_hot" t a -> TensorApply t
+_one_hot args
+  = let scalarArgs
+          = catMaybes
+              [("depth",) . showValue <$> (args !? #depth :: Maybe Int),
+               ("on_value",) . showValue <$> (args !? #on_value :: Maybe Double),
+               ("off_value",) . showValue <$>
+                 (args !? #off_value :: Maybe Double),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "int8",
+                           "uint8"]))]
+        tensorKeyArgs
+          = catMaybes [("indices",) <$> (args !? #indices :: Maybe t)]
+      in apply "one_hot" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_ones_like" t =
+     '[ '("data", AttrOpt t)]
+
+_ones_like ::
+           forall a t .
+             (TensorOp t t, Fullfilled "_ones_like" t a, HasCallStack) =>
+             ArgsHMap "_ones_like" t a -> TensorApply t
+_ones_like args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "ones_like" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_pick" t =
+     '[ '("axis", AttrOpt (Maybe Int)), '("keepdims", AttrOpt Bool),
+        '("mode", AttrOpt (EnumType '["clip", "wrap"])),
+        '("data", AttrOpt t), '("index", AttrOpt t)]
+
+_pick ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_pick" t a, HasCallStack) =>
+        ArgsHMap "_pick" t a -> TensorApply t
+_pick args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
+               ("mode",) . showValue <$>
+                 (args !? #mode :: Maybe (EnumType '["clip", "wrap"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("index",) <$> (args !? #index :: Maybe t)]
+      in apply "pick" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_preloaded_multi_mp_sgd_mom_update" t
+     =
+     '[ '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+_preloaded_multi_mp_sgd_mom_update ::
+                                   forall a t .
+                                     (TensorOp t t,
+                                      Fullfilled "_preloaded_multi_mp_sgd_mom_update" t a,
+                                      HasCallStack) =>
+                                     ArgsHMap "_preloaded_multi_mp_sgd_mom_update" t a ->
+                                       TensorApply t
+_preloaded_multi_mp_sgd_mom_update args
+  = let scalarArgs
+          = catMaybes
+              [("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("num_weights",) . showValue <$>
+                 (args !? #num_weights :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in
+      apply "preloaded_multi_mp_sgd_mom_update" scalarArgs
+        (Right tensorVarArgs)
+
+type instance ParameterList "_preloaded_multi_mp_sgd_update" t =
+     '[ '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+_preloaded_multi_mp_sgd_update ::
+                               forall a t .
+                                 (TensorOp t t, Fullfilled "_preloaded_multi_mp_sgd_update" t a,
+                                  HasCallStack) =>
+                                 ArgsHMap "_preloaded_multi_mp_sgd_update" t a -> TensorApply t
+_preloaded_multi_mp_sgd_update args
+  = let scalarArgs
+          = catMaybes
+              [("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("num_weights",) . showValue <$>
+                 (args !? #num_weights :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in
+      apply "preloaded_multi_mp_sgd_update" scalarArgs
+        (Right tensorVarArgs)
+
+type instance ParameterList "_preloaded_multi_sgd_mom_update" t =
+     '[ '("momentum", AttrOpt Float), '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+_preloaded_multi_sgd_mom_update ::
+                                forall a t .
+                                  (TensorOp t t, Fullfilled "_preloaded_multi_sgd_mom_update" t a,
+                                   HasCallStack) =>
+                                  ArgsHMap "_preloaded_multi_sgd_mom_update" t a -> TensorApply t
+_preloaded_multi_sgd_mom_update args
+  = let scalarArgs
+          = catMaybes
+              [("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("num_weights",) . showValue <$>
+                 (args !? #num_weights :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in
+      apply "preloaded_multi_sgd_mom_update" scalarArgs
+        (Right tensorVarArgs)
+
+type instance ParameterList "_preloaded_multi_sgd_update" t =
+     '[ '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("num_weights", AttrOpt Int),
+        '("data", AttrOpt [t])]
+
+_preloaded_multi_sgd_update ::
+                            forall a t .
+                              (TensorOp t t, Fullfilled "_preloaded_multi_sgd_update" t a,
+                               HasCallStack) =>
+                              ArgsHMap "_preloaded_multi_sgd_update" t a -> TensorApply t
+_preloaded_multi_sgd_update args
+  = let scalarArgs
+          = catMaybes
+              [("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("num_weights",) . showValue <$>
+                 (args !? #num_weights :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in
+      apply "preloaded_multi_sgd_update" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_prod" t =
+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
+        '("exclude", AttrOpt Bool), '("data", AttrOpt t)]
+
+_prod ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_prod" t a, HasCallStack) =>
+        ArgsHMap "_prod" t a -> TensorApply t
+_prod args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "prod" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_radians" t = '[ '("data", AttrOpt t)]
+
+_radians ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_radians" t a, HasCallStack) =>
+           ArgsHMap "_radians" t a -> TensorApply t
+_radians args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "radians" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_rcbrt" t = '[ '("data", AttrOpt t)]
+
+_rcbrt ::
+       forall a t .
+         (TensorOp t t, Fullfilled "_rcbrt" t a, HasCallStack) =>
+         ArgsHMap "_rcbrt" t a -> TensorApply t
+_rcbrt args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "rcbrt" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_reciprocal" t =
+     '[ '("data", AttrOpt t)]
+
+_reciprocal ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_reciprocal" t a, HasCallStack) =>
+              ArgsHMap "_reciprocal" t a -> TensorApply t
+_reciprocal args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "reciprocal" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_relu" t = '[ '("data", AttrOpt t)]
+
+_relu ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_relu" t a, HasCallStack) =>
+        ArgsHMap "_relu" t a -> TensorApply t
+_relu args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "relu" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_repeat" t =
+     '[ '("repeats", AttrReq Int), '("axis", AttrOpt (Maybe Int)),
+        '("data", AttrOpt t)]
+
+_repeat ::
+        forall a t .
+          (TensorOp t t, Fullfilled "_repeat" t a, HasCallStack) =>
+          ArgsHMap "_repeat" t a -> TensorApply t
+_repeat args
+  = let scalarArgs
+          = catMaybes
+              [("repeats",) . showValue <$> (args !? #repeats :: Maybe Int),
+               ("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "repeat" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_reset_arrays" t =
+     '[ '("num_arrays", AttrReq Int), '("data", AttrOpt [t])]
+
+_reset_arrays ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_reset_arrays" t a, HasCallStack) =>
+                ArgsHMap "_reset_arrays" t a -> TensorApply t
+_reset_arrays args
+  = let scalarArgs
+          = catMaybes
+              [("num_arrays",) . showValue <$>
+                 (args !? #num_arrays :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "reset_arrays" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_reshape_like" t =
+     '[ '("lhs_begin", AttrOpt (Maybe Int)),
+        '("lhs_end", AttrOpt (Maybe Int)),
+        '("rhs_begin", AttrOpt (Maybe Int)),
+        '("rhs_end", AttrOpt (Maybe Int)), '("lhs", AttrOpt t),
+        '("rhs", AttrOpt t)]
+
+_reshape_like ::
+              forall a t .
+                (TensorOp t t, Fullfilled "_reshape_like" t a, HasCallStack) =>
+                ArgsHMap "_reshape_like" t a -> TensorApply t
+_reshape_like args
+  = let scalarArgs
+          = catMaybes
+              [("lhs_begin",) . showValue <$>
+                 (args !? #lhs_begin :: Maybe (Maybe Int)),
+               ("lhs_end",) . showValue <$>
+                 (args !? #lhs_end :: Maybe (Maybe Int)),
+               ("rhs_begin",) . showValue <$>
+                 (args !? #rhs_begin :: Maybe (Maybe Int)),
+               ("rhs_end",) . showValue <$>
+                 (args !? #rhs_end :: Maybe (Maybe Int))]
+        tensorKeyArgs
+          = catMaybes
+              [("lhs",) <$> (args !? #lhs :: Maybe t),
+               ("rhs",) <$> (args !? #rhs :: Maybe t)]
+      in
+      apply "reshape_like" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_reverse" t =
+     '[ '("axis", AttrReq [Int]), '("data", AttrOpt t)]
+
+_reverse ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_reverse" t a, HasCallStack) =>
+           ArgsHMap "_reverse" t a -> TensorApply t
+_reverse args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "reverse" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_rint" t = '[ '("data", AttrOpt t)]
+
+_rint ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_rint" t a, HasCallStack) =>
+        ArgsHMap "_rint" t a -> TensorApply t
+_rint args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "rint" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_rmsprop_update" t =
+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
+        '("epsilon", AttrOpt Float), '("wd", AttrOpt Float),
+        '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float),
+        '("clip_weights", AttrOpt Float), '("weight", AttrOpt t),
+        '("grad", AttrOpt t), '("n", AttrOpt t)]
+
+_rmsprop_update ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "_rmsprop_update" t a, HasCallStack) =>
+                  ArgsHMap "_rmsprop_update" t a -> TensorApply t
+_rmsprop_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("clip_weights",) . showValue <$>
+                 (args !? #clip_weights :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("n",) <$> (args !? #n :: Maybe t)]
+      in
+      apply "rmsprop_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_rmspropalex_update" t =
+     '[ '("lr", AttrReq Float), '("gamma1", AttrOpt Float),
+        '("gamma2", AttrOpt Float), '("epsilon", AttrOpt Float),
+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float),
+        '("clip_weights", AttrOpt Float), '("weight", AttrOpt t),
+        '("grad", AttrOpt t), '("n", AttrOpt t), '("g", AttrOpt t),
+        '("delta", AttrOpt t)]
+
+_rmspropalex_update ::
+                    forall a t .
+                      (TensorOp t t, Fullfilled "_rmspropalex_update" t a,
+                       HasCallStack) =>
+                      ArgsHMap "_rmspropalex_update" t a -> TensorApply t
+_rmspropalex_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("gamma1",) . showValue <$> (args !? #gamma1 :: Maybe Float),
+               ("gamma2",) . showValue <$> (args !? #gamma2 :: Maybe Float),
+               ("epsilon",) . showValue <$> (args !? #epsilon :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("clip_weights",) . showValue <$>
+                 (args !? #clip_weights :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("n",) <$> (args !? #n :: Maybe t),
+               ("g",) <$> (args !? #g :: Maybe t),
+               ("delta",) <$> (args !? #delta :: Maybe t)]
+      in
+      apply "rmspropalex_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_round" t = '[ '("data", AttrOpt t)]
+
+_round ::
+       forall a t .
+         (TensorOp t t, Fullfilled "_round" t a, HasCallStack) =>
+         ArgsHMap "_round" t a -> TensorApply t
+_round args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "round" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_rsqrt" t = '[ '("data", AttrOpt t)]
+
+_rsqrt ::
+       forall a t .
+         (TensorOp t t, Fullfilled "_rsqrt" t a, HasCallStack) =>
+         ArgsHMap "_rsqrt" t a -> TensorApply t
+_rsqrt args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "rsqrt" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_scatter_nd" t =
+     '[ '("shape", AttrReq [Int]), '("data", AttrOpt t),
+        '("indices", AttrOpt t)]
+
+_scatter_nd ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_scatter_nd" t a, HasCallStack) =>
+              ArgsHMap "_scatter_nd" t a -> TensorApply t
+_scatter_nd args
+  = let scalarArgs
+          = catMaybes
+              [("shape",) . showValue <$> (args !? #shape :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("indices",) <$> (args !? #indices :: Maybe t)]
+      in
+      apply "scatter_nd" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_sgd_mom_update" t =
+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
+        '("weight", AttrOpt t), '("grad", AttrOpt t), '("mom", AttrOpt t)]
+
+_sgd_mom_update ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "_sgd_mom_update" t a, HasCallStack) =>
+                  ArgsHMap "_sgd_mom_update" t a -> TensorApply t
+_sgd_mom_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("lazy_update",) . showValue <$>
+                 (args !? #lazy_update :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("mom",) <$> (args !? #mom :: Maybe t)]
+      in
+      apply "sgd_mom_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_sgd_update" t =
+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
+        '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("lazy_update", AttrOpt Bool),
+        '("weight", AttrOpt t), '("grad", AttrOpt t)]
+
+_sgd_update ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_sgd_update" t a, HasCallStack) =>
+              ArgsHMap "_sgd_update" t a -> TensorApply t
+_sgd_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("lazy_update",) . showValue <$>
+                 (args !? #lazy_update :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t)]
+      in
+      apply "sgd_update" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_shape_array" t =
+     '[ '("data", AttrOpt t)]
+
+_shape_array ::
+             forall a t .
+               (TensorOp t t, Fullfilled "_shape_array" t a, HasCallStack) =>
+               ArgsHMap "_shape_array" t a -> TensorApply t
+_shape_array args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "shape_array" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_sigmoid" t = '[ '("data", AttrOpt t)]
+
+_sigmoid ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_sigmoid" t a, HasCallStack) =>
+           ArgsHMap "_sigmoid" t a -> TensorApply t
+_sigmoid args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "sigmoid" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_sign" t = '[ '("data", AttrOpt t)]
+
+_sign ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_sign" t a, HasCallStack) =>
+        ArgsHMap "_sign" t a -> TensorApply t
+_sign args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "sign" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_signsgd_update" t =
+     '[ '("lr", AttrReq Float), '("wd", AttrOpt Float),
+        '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("weight", AttrOpt t),
+        '("grad", AttrOpt t)]
+
+_signsgd_update ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "_signsgd_update" t a, HasCallStack) =>
+                  ArgsHMap "_signsgd_update" t a -> TensorApply t
+_signsgd_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t)]
+      in
+      apply "signsgd_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_signum_update" t =
+     '[ '("lr", AttrReq Float), '("momentum", AttrOpt Float),
+        '("wd", AttrOpt Float), '("rescale_grad", AttrOpt Float),
+        '("clip_gradient", AttrOpt Float), '("wd_lh", AttrOpt Float),
+        '("weight", AttrOpt t), '("grad", AttrOpt t), '("mom", AttrOpt t)]
+
+_signum_update ::
+               forall a t .
+                 (TensorOp t t, Fullfilled "_signum_update" t a, HasCallStack) =>
+                 ArgsHMap "_signum_update" t a -> TensorApply t
+_signum_update args
+  = let scalarArgs
+          = catMaybes
+              [("lr",) . showValue <$> (args !? #lr :: Maybe Float),
+               ("momentum",) . showValue <$> (args !? #momentum :: Maybe Float),
+               ("wd",) . showValue <$> (args !? #wd :: Maybe Float),
+               ("rescale_grad",) . showValue <$>
+                 (args !? #rescale_grad :: Maybe Float),
+               ("clip_gradient",) . showValue <$>
+                 (args !? #clip_gradient :: Maybe Float),
+               ("wd_lh",) . showValue <$> (args !? #wd_lh :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes
+              [("weight",) <$> (args !? #weight :: Maybe t),
+               ("grad",) <$> (args !? #grad :: Maybe t),
+               ("mom",) <$> (args !? #mom :: Maybe t)]
+      in
+      apply "signum_update" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_sin" t = '[ '("data", AttrOpt t)]
+
+_sin ::
+     forall a t . (TensorOp t t, Fullfilled "_sin" t a, HasCallStack) =>
+       ArgsHMap "_sin" t a -> TensorApply t
+_sin args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "sin" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_sinh" t = '[ '("data", AttrOpt t)]
+
+_sinh ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_sinh" t a, HasCallStack) =>
+        ArgsHMap "_sinh" t a -> TensorApply t
+_sinh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "sinh" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_size_array" t =
+     '[ '("data", AttrOpt t)]
+
+_size_array ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_size_array" t a, HasCallStack) =>
+              ArgsHMap "_size_array" t a -> TensorApply t
+_size_array args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "size_array" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_slice" t =
+     '[ '("begin", AttrReq [Int]), '("end", AttrReq [Int]),
+        '("step", AttrOpt [Int]), '("data", AttrOpt t)]
+
+_slice ::
+       forall a t .
+         (TensorOp t t, Fullfilled "_slice" t a, HasCallStack) =>
+         ArgsHMap "_slice" t a -> TensorApply t
+_slice args
+  = let scalarArgs
+          = catMaybes
+              [("begin",) . showValue <$> (args !? #begin :: Maybe [Int]),
+               ("end",) . showValue <$> (args !? #end :: Maybe [Int]),
+               ("step",) . showValue <$> (args !? #step :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "slice" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_slice_axis" t =
+     '[ '("axis", AttrReq Int), '("begin", AttrReq Int),
+        '("end", AttrReq (Maybe Int)), '("data", AttrOpt t)]
+
+_slice_axis ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_slice_axis" t a, HasCallStack) =>
+              ArgsHMap "_slice_axis" t a -> TensorApply t
+_slice_axis args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
+               ("begin",) . showValue <$> (args !? #begin :: Maybe Int),
+               ("end",) . showValue <$> (args !? #end :: Maybe (Maybe Int))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "slice_axis" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_slice_like" t =
+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt t),
+        '("shape_like", AttrOpt t)]
+
+_slice_like ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_slice_like" t a, HasCallStack) =>
+              ArgsHMap "_slice_like" t a -> TensorApply t
+_slice_like args
+  = let scalarArgs
+          = catMaybes
+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("shape_like",) <$> (args !? #shape_like :: Maybe t)]
+      in
+      apply "slice_like" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_smooth_l1" t =
+     '[ '("scalar", AttrOpt Float), '("data", AttrOpt t)]
+
+_smooth_l1 ::
+           forall a t .
+             (TensorOp t t, Fullfilled "_smooth_l1" t a, HasCallStack) =>
+             ArgsHMap "_smooth_l1" t a -> TensorApply t
+_smooth_l1 args
+  = let scalarArgs
+          = catMaybes
+              [("scalar",) . showValue <$> (args !? #scalar :: Maybe Float)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "smooth_l1" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_softmax" t =
+     '[ '("axis", AttrOpt Int),
+        '("temperature", AttrOpt (Maybe Double)),
+        '("dtype",
+          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),
+        '("use_length", AttrOpt (Maybe Bool)), '("data", AttrOpt t),
+        '("length", AttrOpt t)]
+
+_softmax ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_softmax" t a, HasCallStack) =>
+           ArgsHMap "_softmax" t a -> TensorApply t
+_softmax args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
+               ("temperature",) . showValue <$>
+                 (args !? #temperature :: Maybe (Maybe Double)),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (Maybe (EnumType '["float16", "float32", "float64"]))),
+               ("use_length",) . showValue <$>
+                 (args !? #use_length :: Maybe (Maybe Bool))]
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("length",) <$> (args !? #length :: Maybe t)]
+      in apply "softmax" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_softmax_cross_entropy" t =
+     '[ '("data", AttrOpt t), '("label", AttrOpt t)]
+
+_softmax_cross_entropy ::
+                       forall a t .
+                         (TensorOp t t, Fullfilled "_softmax_cross_entropy" t a,
+                          HasCallStack) =>
+                         ArgsHMap "_softmax_cross_entropy" t a -> TensorApply t
+_softmax_cross_entropy args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("data",) <$> (args !? #data :: Maybe t),
+               ("label",) <$> (args !? #label :: Maybe t)]
+      in
+      apply "softmax_cross_entropy" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_softmin" t =
+     '[ '("axis", AttrOpt Int),
+        '("temperature", AttrOpt (Maybe Double)),
+        '("dtype",
+          AttrOpt (Maybe (EnumType '["float16", "float32", "float64"]))),
+        '("use_length", AttrOpt (Maybe Bool)), '("data", AttrOpt t)]
+
+_softmin ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_softmin" t a, HasCallStack) =>
+           ArgsHMap "_softmin" t a -> TensorApply t
+_softmin args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
+               ("temperature",) . showValue <$>
+                 (args !? #temperature :: Maybe (Maybe Double)),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe (Maybe (EnumType '["float16", "float32", "float64"]))),
+               ("use_length",) . showValue <$>
+                 (args !? #use_length :: Maybe (Maybe Bool))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "softmin" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_softsign" t =
+     '[ '("data", AttrOpt t)]
+
+_softsign ::
+          forall a t .
+            (TensorOp t t, Fullfilled "_softsign" t a, HasCallStack) =>
+            ArgsHMap "_softsign" t a -> TensorApply t
+_softsign args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "softsign" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_sort" t =
+     '[ '("axis", AttrOpt (Maybe Int)), '("is_ascend", AttrOpt Bool),
+        '("data", AttrOpt t)]
+
+_sort ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_sort" t a, HasCallStack) =>
+        ArgsHMap "_sort" t a -> TensorApply t
+_sort args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "sort" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_space_to_depth" t =
+     '[ '("block_size", AttrReq Int), '("data", AttrOpt t)]
+
+_space_to_depth ::
+                forall a t .
+                  (TensorOp t t, Fullfilled "_space_to_depth" t a, HasCallStack) =>
+                  ArgsHMap "_space_to_depth" t a -> TensorApply t
+_space_to_depth args
+  = let scalarArgs
+          = catMaybes
+              [("block_size",) . showValue <$>
+                 (args !? #block_size :: Maybe Int)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "space_to_depth" scalarArgs
+        (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_sqrt" t = '[ '("data", AttrOpt t)]
+
+_sqrt ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_sqrt" t a, HasCallStack) =>
+        ArgsHMap "_sqrt" t a -> TensorApply t
+_sqrt args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "sqrt" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_square" t = '[ '("data", AttrOpt t)]
+
+_square ::
+        forall a t .
+          (TensorOp t t, Fullfilled "_square" t a, HasCallStack) =>
+          ArgsHMap "_square" t a -> TensorApply t
+_square args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "square" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_squeeze" t =
+     '[ '("axis", AttrOpt (Maybe [Int])), '("data", AttrOpt t)]
+
+_squeeze ::
+         forall a t .
+           (TensorOp t t, Fullfilled "_squeeze" t a, HasCallStack) =>
+           ArgsHMap "_squeeze" t a -> TensorApply t
+_squeeze args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "squeeze" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_stack" t =
+     '[ '("axis", AttrOpt Int), '("num_args", AttrReq Int),
+        '("data", AttrOpt [t])]
+
+_stack ::
+       forall a t .
+         (TensorOp t t, Fullfilled "_stack" t a, HasCallStack) =>
+         ArgsHMap "_stack" t a -> TensorApply t
+_stack args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
+               ("num_args",) . showValue <$> (args !? #num_args :: Maybe Int)]
+        tensorKeyArgs = catMaybes []
+        tensorVarArgs = fromMaybe [] (args !? #data :: Maybe [t])
+      in apply "stack" scalarArgs (Right tensorVarArgs)
+
+type instance ParameterList "_sum" t =
+     '[ '("axis", AttrOpt (Maybe [Int])), '("keepdims", AttrOpt Bool),
+        '("exclude", AttrOpt Bool), '("data", AttrOpt t)]
+
+_sum ::
+     forall a t . (TensorOp t t, Fullfilled "_sum" t a, HasCallStack) =>
+       ArgsHMap "_sum" t a -> TensorApply t
+_sum args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe [Int])),
+               ("keepdims",) . showValue <$> (args !? #keepdims :: Maybe Bool),
+               ("exclude",) . showValue <$> (args !? #exclude :: Maybe Bool)]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "sum" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_take" t =
+     '[ '("axis", AttrOpt Int),
+        '("mode", AttrOpt (EnumType '["clip", "raise", "wrap"])),
+        '("a", AttrOpt t), '("indices", AttrOpt t)]
+
+_take ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_take" t a, HasCallStack) =>
+        ArgsHMap "_take" t a -> TensorApply t
+_take args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe Int),
+               ("mode",) . showValue <$>
+                 (args !? #mode :: Maybe (EnumType '["clip", "raise", "wrap"]))]
+        tensorKeyArgs
+          = catMaybes
+              [("a",) <$> (args !? #a :: Maybe t),
+               ("indices",) <$> (args !? #indices :: Maybe t)]
+      in apply "take" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_tan" t = '[ '("data", AttrOpt t)]
+
+_tan ::
+     forall a t . (TensorOp t t, Fullfilled "_tan" t a, HasCallStack) =>
+       ArgsHMap "_tan" t a -> TensorApply t
+_tan args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "tan" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_tanh" t = '[ '("data", AttrOpt t)]
+
+_tanh ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_tanh" t a, HasCallStack) =>
+        ArgsHMap "_tanh" t a -> TensorApply t
+_tanh args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "tanh" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_tile" t =
+     '[ '("reps", AttrReq [Int]), '("data", AttrOpt t)]
+
+_tile ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_tile" t a, HasCallStack) =>
+        ArgsHMap "_tile" t a -> TensorApply t
+_tile args
+  = let scalarArgs
+          = catMaybes
+              [("reps",) . showValue <$> (args !? #reps :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "tile" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_topk" t =
+     '[ '("axis", AttrOpt (Maybe Int)), '("k", AttrOpt Int),
+        '("ret_typ",
+          AttrOpt (EnumType '["both", "indices", "mask", "value"])),
+        '("is_ascend", AttrOpt Bool),
+        '("dtype",
+          AttrOpt
+            (EnumType
+               '["float16", "float32", "float64", "int32", "int64", "uint8"])),
+        '("data", AttrOpt t)]
+
+_topk ::
+      forall a t .
+        (TensorOp t t, Fullfilled "_topk" t a, HasCallStack) =>
+        ArgsHMap "_topk" t a -> TensorApply t
+_topk args
+  = let scalarArgs
+          = catMaybes
+              [("axis",) . showValue <$> (args !? #axis :: Maybe (Maybe Int)),
+               ("k",) . showValue <$> (args !? #k :: Maybe Int),
+               ("ret_typ",) . showValue <$>
+                 (args !? #ret_typ ::
+                    Maybe (EnumType '["both", "indices", "mask", "value"])),
+               ("is_ascend",) . showValue <$> (args !? #is_ascend :: Maybe Bool),
+               ("dtype",) . showValue <$>
+                 (args !? #dtype ::
+                    Maybe
+                      (EnumType
+                         '["float16", "float32", "float64", "int32", "int64", "uint8"]))]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "topk" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_transpose" t =
+     '[ '("axes", AttrOpt [Int]), '("data", AttrOpt t)]
+
+_transpose ::
+           forall a t .
+             (TensorOp t t, Fullfilled "_transpose" t a, HasCallStack) =>
+             ArgsHMap "_transpose" t a -> TensorApply t
+_transpose args
+  = let scalarArgs
+          = catMaybes
+              [("axes",) . showValue <$> (args !? #axes :: Maybe [Int])]
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "transpose" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_trunc" t = '[ '("data", AttrOpt t)]
+
+_trunc ::
+       forall a t .
+         (TensorOp t t, Fullfilled "_trunc" t a, HasCallStack) =>
+         ArgsHMap "_trunc" t a -> TensorApply t
+_trunc args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in apply "trunc" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_where" t =
+     '[ '("condition", AttrOpt t), '("x", AttrOpt t), '("y", AttrOpt t)]
+
+_where ::
+       forall a t .
+         (TensorOp t t, Fullfilled "_where" t a, HasCallStack) =>
+         ArgsHMap "_where" t a -> TensorApply t
+_where args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes
+              [("condition",) <$> (args !? #condition :: Maybe t),
+               ("x",) <$> (args !? #x :: Maybe t),
+               ("y",) <$> (args !? #y :: Maybe t)]
+      in apply "where" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
+
+type instance ParameterList "_zeros_like" t =
+     '[ '("data", AttrOpt t)]
+
+_zeros_like ::
+            forall a t .
+              (TensorOp t t, Fullfilled "_zeros_like" t a, HasCallStack) =>
+              ArgsHMap "_zeros_like" t a -> TensorApply t
+_zeros_like args
+  = let scalarArgs = catMaybes []
+        tensorKeyArgs
+          = catMaybes [("data",) <$> (args !? #data :: Maybe t)]
+      in
+      apply "zeros_like" scalarArgs (Left (tensorKeyArgs :: [(Text, t)]))
diff --git a/ops/dummy/MXNet/Base/DataIter.hs b/ops/dummy/MXNet/Base/DataIter.hs
new file mode 100644
--- /dev/null
+++ b/ops/dummy/MXNet/Base/DataIter.hs
@@ -0,0 +1,1 @@
+module MXNet.Base.DataIter where
diff --git a/ops/dummy/MXNet/Base/Operators/Tensor.hs b/ops/dummy/MXNet/Base/Operators/Tensor.hs
new file mode 100644
--- /dev/null
+++ b/ops/dummy/MXNet/Base/Operators/Tensor.hs
@@ -0,0 +1,5 @@
+module MXNet.Base.Operators.Tensor where
+
+import           RIO
+
+__copyto = error "tensors operators not generated."