fei-base 0.2.0.0 → 1.0.0

raw patch · 30 files changed

+17144/−127340 lines, 30 filesdep +attoparsecdep +deepseqdep +lensdep −c2hs-extradep −directorydep −fei-basedep ~tuple-opsdep ~vector

Dependencies added: attoparsec, deepseq, lens, rio, store

Dependencies removed: c2hs-extra, directory, fei-base, filepath, mtl, text

Dependency ranges changed: tuple-ops, vector

Files

• README.md +7/−8
• c-apis/MXNet/Base.hs +10/−8
• c-apis/MXNet/Base/Executor.hs +56/−2
• c-apis/MXNet/Base/NDArray.hs +105/−32
• c-apis/MXNet/Base/NDArray.hs-boot +6/−0
• c-apis/MXNet/Base/ParserUtils.hs +22/−0
• c-apis/MXNet/Base/Raw/Common.chs +100/−50
• c-apis/MXNet/Base/Raw/DataIter.chs +43/−32
• c-apis/MXNet/Base/Raw/Executor.chs +280/−77
• c-apis/MXNet/Base/Raw/NDArray.chs +60/−17
• c-apis/MXNet/Base/Raw/Symbol.chs +208/−76
• c-apis/MXNet/Base/Spec/HMap.hs +3/−3
• c-apis/MXNet/Base/Spec/Operator.hs +99/−86
• c-apis/MXNet/Base/Symbol.hs +129/−76
• c-apis/MXNet/Base/Tensor.hs +78/−0
• c-apis/MXNet/Base/Types.hs +35/−16
• cmdline/Main.hs +213/−249
• fei-base.cabal +49/−43
• ops/1.0/MXNet/Base/Operators/NDArray.hs +0/−16434
• ops/1.0/MXNet/Base/Operators/Symbol.hs +0/−9339
• ops/1.3/MXNet/Base/Operators/NDArray.hs +0/−20011
• ops/1.3/MXNet/Base/Operators/Symbol.hs +0/−11404
• ops/1.4/MXNet/Base/Operators/NDArray.hs +0/−21107
• ops/1.4/MXNet/Base/Operators/Symbol.hs +0/−12038
• ops/1.5/MXNet/Base/Operators/NDArray.hs +0/−23053
• ops/1.5/MXNet/Base/Operators/Symbol.hs +0/−13179
• ops/1.6/MXNet/Base/DataIter.hs +1055/−0
• ops/1.6/MXNet/Base/Operators/Tensor.hs +14580/−0
• ops/dummy/MXNet/Base/DataIter.hs +1/−0
• ops/dummy/MXNet/Base/Operators/Tensor.hs +5/−0

@@ -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

@@ -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

@@ -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

@@ -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)

@@ -0,0 +1,6 @@+module MXNet.Base.NDArray where++import qualified MXNet.Base.Raw               as I++newtype NDArray a = NDArray { unNDArray :: I.NDArrayHandle}+

@@ -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 ',')

@@ -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)

@@ -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'

@@ -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)

@@ -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

@@ -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  -- {#

@@ -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))

@@ -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)

@@ -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+

@@ -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++

@@ -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

@@ -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 = (),

@@ -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

@@ -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 ()